TreeTransform.h revision a2813cec2605ce7878d1b13471d685f689b251af
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 QualType T = getDerived().TransformType(Arg.getAsType()); 1888 if (T.isNull()) 1889 return TemplateArgument(); 1890 return TemplateArgument(Arg.getLocation(), T); 1891 } 1892 1893 case TemplateArgument::Declaration: { 1894 Decl *D = getDerived().TransformDecl(Arg.getAsDecl()); 1895 if (!D) 1896 return TemplateArgument(); 1897 return TemplateArgument(Arg.getLocation(), D); 1898 } 1899 1900 case TemplateArgument::Expression: { 1901 // Template argument expressions are not potentially evaluated. 1902 EnterExpressionEvaluationContext Unevaluated(getSema(), 1903 Action::Unevaluated); 1904 1905 Sema::OwningExprResult E = getDerived().TransformExpr(Arg.getAsExpr()); 1906 if (E.isInvalid()) 1907 return TemplateArgument(); 1908 return TemplateArgument(E.takeAs<Expr>()); 1909 } 1910 1911 case TemplateArgument::Pack: { 1912 llvm::SmallVector<TemplateArgument, 4> TransformedArgs; 1913 TransformedArgs.reserve(Arg.pack_size()); 1914 for (TemplateArgument::pack_iterator A = Arg.pack_begin(), 1915 AEnd = Arg.pack_end(); 1916 A != AEnd; ++A) { 1917 TemplateArgument TA = getDerived().TransformTemplateArgument(*A); 1918 if (TA.isNull()) 1919 return TA; 1920 1921 TransformedArgs.push_back(TA); 1922 } 1923 TemplateArgument Result; 1924 Result.setArgumentPack(TransformedArgs.data(), TransformedArgs.size(), 1925 true); 1926 return Result; 1927 } 1928 } 1929 1930 // Work around bogus GCC warning 1931 return TemplateArgument(); 1932} 1933 1934//===----------------------------------------------------------------------===// 1935// Type transformation 1936//===----------------------------------------------------------------------===// 1937 1938template<typename Derived> 1939QualType TreeTransform<Derived>::TransformType(QualType T) { 1940 if (getDerived().AlreadyTransformed(T)) 1941 return T; 1942 1943 // Temporary workaround. All of these transformations should 1944 // eventually turn into transformations on TypeLocs. 1945 DeclaratorInfo *DI = getSema().Context.CreateDeclaratorInfo(T); 1946 DI->getTypeLoc().initialize(getDerived().getBaseLocation()); 1947 1948 DeclaratorInfo *NewDI = getDerived().TransformType(DI); 1949 1950 if (!NewDI) 1951 return QualType(); 1952 1953 return NewDI->getType(); 1954} 1955 1956template<typename Derived> 1957DeclaratorInfo *TreeTransform<Derived>::TransformType(DeclaratorInfo *DI) { 1958 if (getDerived().AlreadyTransformed(DI->getType())) 1959 return DI; 1960 1961 TypeLocBuilder TLB; 1962 1963 TypeLoc TL = DI->getTypeLoc(); 1964 TLB.reserve(TL.getFullDataSize()); 1965 1966 QualType Result = getDerived().TransformType(TLB, TL); 1967 if (Result.isNull()) 1968 return 0; 1969 1970 return TLB.getDeclaratorInfo(SemaRef.Context, Result); 1971} 1972 1973template<typename Derived> 1974QualType 1975TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T) { 1976 switch (T.getTypeLocClass()) { 1977#define ABSTRACT_TYPELOC(CLASS, PARENT) 1978#define TYPELOC(CLASS, PARENT) \ 1979 case TypeLoc::CLASS: \ 1980 return getDerived().Transform##CLASS##Type(TLB, cast<CLASS##TypeLoc>(T)); 1981#include "clang/AST/TypeLocNodes.def" 1982 } 1983 1984 llvm::llvm_unreachable("unhandled type loc!"); 1985 return QualType(); 1986} 1987 1988/// FIXME: By default, this routine adds type qualifiers only to types 1989/// that can have qualifiers, and silently suppresses those qualifiers 1990/// that are not permitted (e.g., qualifiers on reference or function 1991/// types). This is the right thing for template instantiation, but 1992/// probably not for other clients. 1993template<typename Derived> 1994QualType 1995TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB, 1996 QualifiedTypeLoc T) { 1997 Qualifiers Quals = T.getType().getQualifiers(); 1998 1999 QualType Result = getDerived().TransformType(TLB, T.getUnqualifiedLoc()); 2000 if (Result.isNull()) 2001 return QualType(); 2002 2003 // Silently suppress qualifiers if the result type can't be qualified. 2004 // FIXME: this is the right thing for template instantiation, but 2005 // probably not for other clients. 2006 if (Result->isFunctionType() || Result->isReferenceType()) 2007 return Result; 2008 2009 Result = SemaRef.Context.getQualifiedType(Result, Quals); 2010 2011 TLB.push<QualifiedTypeLoc>(Result); 2012 2013 // No location information to preserve. 2014 2015 return Result; 2016} 2017 2018template <class TyLoc> static inline 2019QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) { 2020 TyLoc NewT = TLB.push<TyLoc>(T.getType()); 2021 NewT.setNameLoc(T.getNameLoc()); 2022 return T.getType(); 2023} 2024 2025// Ugly metaprogramming macros because I couldn't be bothered to make 2026// the equivalent template version work. 2027#define TransformPointerLikeType(TypeClass) do { \ 2028 QualType PointeeType \ 2029 = getDerived().TransformType(TLB, TL.getPointeeLoc()); \ 2030 if (PointeeType.isNull()) \ 2031 return QualType(); \ 2032 \ 2033 QualType Result = TL.getType(); \ 2034 if (getDerived().AlwaysRebuild() || \ 2035 PointeeType != TL.getPointeeLoc().getType()) { \ 2036 Result = getDerived().Rebuild##TypeClass(PointeeType); \ 2037 if (Result.isNull()) \ 2038 return QualType(); \ 2039 } \ 2040 \ 2041 TypeClass##Loc NewT = TLB.push<TypeClass##Loc>(Result); \ 2042 NewT.setSigilLoc(TL.getSigilLoc()); \ 2043 \ 2044 return Result; \ 2045} while(0) 2046 2047// Reference collapsing forces us to transform reference types 2048// differently from the other pointer-like types. 2049#define TransformReferenceType(TypeClass) do { \ 2050 QualType PointeeType \ 2051 = getDerived().TransformType(TLB, TL.getPointeeLoc()); \ 2052 if (PointeeType.isNull()) \ 2053 return QualType(); \ 2054 \ 2055 QualType Result = TL.getType(); \ 2056 if (getDerived().AlwaysRebuild() || \ 2057 PointeeType != TL.getPointeeLoc().getType()) { \ 2058 Result = getDerived().Rebuild##TypeClass(PointeeType); \ 2059 if (Result.isNull()) \ 2060 return QualType(); \ 2061 } \ 2062 \ 2063 /* Workaround: rebuild doesn't always change the type */ \ 2064 /* FIXME: avoid losing this location information. */ \ 2065 if (Result == PointeeType) \ 2066 return Result; \ 2067 ReferenceTypeLoc NewTL; \ 2068 if (isa<LValueReferenceType>(Result)) \ 2069 NewTL = TLB.push<LValueReferenceTypeLoc>(Result); \ 2070 else \ 2071 NewTL = TLB.push<RValueReferenceTypeLoc>(Result); \ 2072 NewTL.setSigilLoc(TL.getSigilLoc()); \ 2073 return Result; \ 2074} while (0) 2075 2076template<typename Derived> 2077QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB, 2078 BuiltinTypeLoc T) { 2079 return TransformTypeSpecType(TLB, T); 2080} 2081 2082template<typename Derived> 2083QualType 2084TreeTransform<Derived>::TransformFixedWidthIntType(TypeLocBuilder &TLB, 2085 FixedWidthIntTypeLoc T) { 2086 return TransformTypeSpecType(TLB, T); 2087} 2088 2089template<typename Derived> 2090QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB, 2091 ComplexTypeLoc T) { 2092 // FIXME: recurse? 2093 return TransformTypeSpecType(TLB, T); 2094} 2095 2096template<typename Derived> 2097QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB, 2098 PointerTypeLoc TL) { 2099 TransformPointerLikeType(PointerType); 2100} 2101 2102template<typename Derived> 2103QualType 2104TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB, 2105 BlockPointerTypeLoc TL) { 2106 TransformPointerLikeType(BlockPointerType); 2107} 2108 2109template<typename Derived> 2110QualType 2111TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB, 2112 LValueReferenceTypeLoc TL) { 2113 TransformReferenceType(LValueReferenceType); 2114} 2115 2116template<typename Derived> 2117QualType 2118TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB, 2119 RValueReferenceTypeLoc TL) { 2120 TransformReferenceType(RValueReferenceType); 2121} 2122 2123template<typename Derived> 2124QualType 2125TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB, 2126 MemberPointerTypeLoc TL) { 2127 MemberPointerType *T = TL.getTypePtr(); 2128 2129 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); 2130 if (PointeeType.isNull()) 2131 return QualType(); 2132 2133 // TODO: preserve source information for this. 2134 QualType ClassType 2135 = getDerived().TransformType(QualType(T->getClass(), 0)); 2136 if (ClassType.isNull()) 2137 return QualType(); 2138 2139 QualType Result = TL.getType(); 2140 if (getDerived().AlwaysRebuild() || 2141 PointeeType != T->getPointeeType() || 2142 ClassType != QualType(T->getClass(), 0)) { 2143 Result = getDerived().RebuildMemberPointerType(PointeeType, ClassType); 2144 if (Result.isNull()) 2145 return QualType(); 2146 } 2147 2148 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result); 2149 NewTL.setSigilLoc(TL.getSigilLoc()); 2150 2151 return Result; 2152} 2153 2154template<typename Derived> 2155QualType 2156TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB, 2157 ConstantArrayTypeLoc TL) { 2158 ConstantArrayType *T = TL.getTypePtr(); 2159 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 2160 if (ElementType.isNull()) 2161 return QualType(); 2162 2163 QualType Result = TL.getType(); 2164 if (getDerived().AlwaysRebuild() || 2165 ElementType != T->getElementType()) { 2166 Result = getDerived().RebuildConstantArrayType(ElementType, 2167 T->getSizeModifier(), 2168 T->getSize(), 2169 T->getIndexTypeCVRQualifiers()); 2170 if (Result.isNull()) 2171 return QualType(); 2172 } 2173 2174 ConstantArrayTypeLoc NewTL = TLB.push<ConstantArrayTypeLoc>(Result); 2175 NewTL.setLBracketLoc(TL.getLBracketLoc()); 2176 NewTL.setRBracketLoc(TL.getRBracketLoc()); 2177 2178 Expr *Size = TL.getSizeExpr(); 2179 if (Size) { 2180 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2181 Size = getDerived().TransformExpr(Size).template takeAs<Expr>(); 2182 } 2183 NewTL.setSizeExpr(Size); 2184 2185 return Result; 2186} 2187 2188template<typename Derived> 2189QualType TreeTransform<Derived>::TransformIncompleteArrayType( 2190 TypeLocBuilder &TLB, 2191 IncompleteArrayTypeLoc TL) { 2192 IncompleteArrayType *T = TL.getTypePtr(); 2193 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 2194 if (ElementType.isNull()) 2195 return QualType(); 2196 2197 QualType Result = TL.getType(); 2198 if (getDerived().AlwaysRebuild() || 2199 ElementType != T->getElementType()) { 2200 Result = getDerived().RebuildIncompleteArrayType(ElementType, 2201 T->getSizeModifier(), 2202 T->getIndexTypeCVRQualifiers()); 2203 if (Result.isNull()) 2204 return QualType(); 2205 } 2206 2207 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result); 2208 NewTL.setLBracketLoc(TL.getLBracketLoc()); 2209 NewTL.setRBracketLoc(TL.getRBracketLoc()); 2210 NewTL.setSizeExpr(0); 2211 2212 return Result; 2213} 2214 2215template<typename Derived> 2216QualType 2217TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB, 2218 VariableArrayTypeLoc TL) { 2219 VariableArrayType *T = TL.getTypePtr(); 2220 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 2221 if (ElementType.isNull()) 2222 return QualType(); 2223 2224 // Array bounds are not potentially evaluated contexts 2225 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2226 2227 Sema::OwningExprResult SizeResult 2228 = getDerived().TransformExpr(T->getSizeExpr()); 2229 if (SizeResult.isInvalid()) 2230 return QualType(); 2231 2232 Expr *Size = static_cast<Expr*>(SizeResult.get()); 2233 2234 QualType Result = TL.getType(); 2235 if (getDerived().AlwaysRebuild() || 2236 ElementType != T->getElementType() || 2237 Size != T->getSizeExpr()) { 2238 Result = getDerived().RebuildVariableArrayType(ElementType, 2239 T->getSizeModifier(), 2240 move(SizeResult), 2241 T->getIndexTypeCVRQualifiers(), 2242 T->getBracketsRange()); 2243 if (Result.isNull()) 2244 return QualType(); 2245 } 2246 else SizeResult.take(); 2247 2248 VariableArrayTypeLoc NewTL = TLB.push<VariableArrayTypeLoc>(Result); 2249 NewTL.setLBracketLoc(TL.getLBracketLoc()); 2250 NewTL.setRBracketLoc(TL.getRBracketLoc()); 2251 NewTL.setSizeExpr(Size); 2252 2253 return Result; 2254} 2255 2256template<typename Derived> 2257QualType 2258TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB, 2259 DependentSizedArrayTypeLoc TL) { 2260 DependentSizedArrayType *T = TL.getTypePtr(); 2261 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 2262 if (ElementType.isNull()) 2263 return QualType(); 2264 2265 // Array bounds are not potentially evaluated contexts 2266 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2267 2268 Sema::OwningExprResult SizeResult 2269 = getDerived().TransformExpr(T->getSizeExpr()); 2270 if (SizeResult.isInvalid()) 2271 return QualType(); 2272 2273 Expr *Size = static_cast<Expr*>(SizeResult.get()); 2274 2275 QualType Result = TL.getType(); 2276 if (getDerived().AlwaysRebuild() || 2277 ElementType != T->getElementType() || 2278 Size != T->getSizeExpr()) { 2279 Result = getDerived().RebuildDependentSizedArrayType(ElementType, 2280 T->getSizeModifier(), 2281 move(SizeResult), 2282 T->getIndexTypeCVRQualifiers(), 2283 T->getBracketsRange()); 2284 if (Result.isNull()) 2285 return QualType(); 2286 } 2287 else SizeResult.take(); 2288 2289 // We might have any sort of array type now, but fortunately they 2290 // all have the same location layout. 2291 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result); 2292 NewTL.setLBracketLoc(TL.getLBracketLoc()); 2293 NewTL.setRBracketLoc(TL.getRBracketLoc()); 2294 NewTL.setSizeExpr(Size); 2295 2296 return Result; 2297} 2298 2299template<typename Derived> 2300QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType( 2301 TypeLocBuilder &TLB, 2302 DependentSizedExtVectorTypeLoc TL) { 2303 DependentSizedExtVectorType *T = TL.getTypePtr(); 2304 2305 // FIXME: ext vector locs should be nested 2306 QualType ElementType = getDerived().TransformType(T->getElementType()); 2307 if (ElementType.isNull()) 2308 return QualType(); 2309 2310 // Vector sizes are not potentially evaluated contexts 2311 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2312 2313 Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); 2314 if (Size.isInvalid()) 2315 return QualType(); 2316 2317 QualType Result = TL.getType(); 2318 if (getDerived().AlwaysRebuild() || 2319 ElementType != T->getElementType() || 2320 Size.get() != T->getSizeExpr()) { 2321 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType, 2322 move(Size), 2323 T->getAttributeLoc()); 2324 if (Result.isNull()) 2325 return QualType(); 2326 } 2327 else Size.take(); 2328 2329 // Result might be dependent or not. 2330 if (isa<DependentSizedExtVectorType>(Result)) { 2331 DependentSizedExtVectorTypeLoc NewTL 2332 = TLB.push<DependentSizedExtVectorTypeLoc>(Result); 2333 NewTL.setNameLoc(TL.getNameLoc()); 2334 } else { 2335 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); 2336 NewTL.setNameLoc(TL.getNameLoc()); 2337 } 2338 2339 return Result; 2340} 2341 2342template<typename Derived> 2343QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB, 2344 VectorTypeLoc TL) { 2345 VectorType *T = TL.getTypePtr(); 2346 QualType ElementType = getDerived().TransformType(T->getElementType()); 2347 if (ElementType.isNull()) 2348 return QualType(); 2349 2350 QualType Result = TL.getType(); 2351 if (getDerived().AlwaysRebuild() || 2352 ElementType != T->getElementType()) { 2353 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements()); 2354 if (Result.isNull()) 2355 return QualType(); 2356 } 2357 2358 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result); 2359 NewTL.setNameLoc(TL.getNameLoc()); 2360 2361 return Result; 2362} 2363 2364template<typename Derived> 2365QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB, 2366 ExtVectorTypeLoc TL) { 2367 VectorType *T = TL.getTypePtr(); 2368 QualType ElementType = getDerived().TransformType(T->getElementType()); 2369 if (ElementType.isNull()) 2370 return QualType(); 2371 2372 QualType Result = TL.getType(); 2373 if (getDerived().AlwaysRebuild() || 2374 ElementType != T->getElementType()) { 2375 Result = getDerived().RebuildExtVectorType(ElementType, 2376 T->getNumElements(), 2377 /*FIXME*/ SourceLocation()); 2378 if (Result.isNull()) 2379 return QualType(); 2380 } 2381 2382 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); 2383 NewTL.setNameLoc(TL.getNameLoc()); 2384 2385 return Result; 2386} 2387 2388template<typename Derived> 2389QualType 2390TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB, 2391 FunctionProtoTypeLoc TL) { 2392 FunctionProtoType *T = TL.getTypePtr(); 2393 QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 2394 if (ResultType.isNull()) 2395 return QualType(); 2396 2397 // Transform the parameters. 2398 llvm::SmallVector<QualType, 4> ParamTypes; 2399 llvm::SmallVector<ParmVarDecl*, 4> ParamDecls; 2400 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 2401 ParmVarDecl *OldParm = TL.getArg(i); 2402 2403 QualType NewType; 2404 ParmVarDecl *NewParm; 2405 2406 if (OldParm) { 2407 DeclaratorInfo *OldDI = OldParm->getDeclaratorInfo(); 2408 assert(OldDI->getType() == T->getArgType(i)); 2409 2410 DeclaratorInfo *NewDI = getDerived().TransformType(OldDI); 2411 if (!NewDI) 2412 return QualType(); 2413 2414 if (NewDI == OldDI) 2415 NewParm = OldParm; 2416 else 2417 NewParm = ParmVarDecl::Create(SemaRef.Context, 2418 OldParm->getDeclContext(), 2419 OldParm->getLocation(), 2420 OldParm->getIdentifier(), 2421 NewDI->getType(), 2422 NewDI, 2423 OldParm->getStorageClass(), 2424 /* DefArg */ NULL); 2425 NewType = NewParm->getType(); 2426 2427 // Deal with the possibility that we don't have a parameter 2428 // declaration for this parameter. 2429 } else { 2430 NewParm = 0; 2431 2432 QualType OldType = T->getArgType(i); 2433 NewType = getDerived().TransformType(OldType); 2434 if (NewType.isNull()) 2435 return QualType(); 2436 } 2437 2438 ParamTypes.push_back(NewType); 2439 ParamDecls.push_back(NewParm); 2440 } 2441 2442 QualType Result = TL.getType(); 2443 if (getDerived().AlwaysRebuild() || 2444 ResultType != T->getResultType() || 2445 !std::equal(T->arg_type_begin(), T->arg_type_end(), ParamTypes.begin())) { 2446 Result = getDerived().RebuildFunctionProtoType(ResultType, 2447 ParamTypes.data(), 2448 ParamTypes.size(), 2449 T->isVariadic(), 2450 T->getTypeQuals()); 2451 if (Result.isNull()) 2452 return QualType(); 2453 } 2454 2455 FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result); 2456 NewTL.setLParenLoc(TL.getLParenLoc()); 2457 NewTL.setRParenLoc(TL.getRParenLoc()); 2458 for (unsigned i = 0, e = NewTL.getNumArgs(); i != e; ++i) 2459 NewTL.setArg(i, ParamDecls[i]); 2460 2461 return Result; 2462} 2463 2464template<typename Derived> 2465QualType TreeTransform<Derived>::TransformFunctionNoProtoType( 2466 TypeLocBuilder &TLB, 2467 FunctionNoProtoTypeLoc TL) { 2468 FunctionNoProtoType *T = TL.getTypePtr(); 2469 QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 2470 if (ResultType.isNull()) 2471 return QualType(); 2472 2473 QualType Result = TL.getType(); 2474 if (getDerived().AlwaysRebuild() || 2475 ResultType != T->getResultType()) 2476 Result = getDerived().RebuildFunctionNoProtoType(ResultType); 2477 2478 FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result); 2479 NewTL.setLParenLoc(TL.getLParenLoc()); 2480 NewTL.setRParenLoc(TL.getRParenLoc()); 2481 2482 return Result; 2483} 2484 2485template<typename Derived> 2486QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB, 2487 TypedefTypeLoc TL) { 2488 TypedefType *T = TL.getTypePtr(); 2489 TypedefDecl *Typedef 2490 = cast_or_null<TypedefDecl>(getDerived().TransformDecl(T->getDecl())); 2491 if (!Typedef) 2492 return QualType(); 2493 2494 QualType Result = TL.getType(); 2495 if (getDerived().AlwaysRebuild() || 2496 Typedef != T->getDecl()) { 2497 Result = getDerived().RebuildTypedefType(Typedef); 2498 if (Result.isNull()) 2499 return QualType(); 2500 } 2501 2502 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result); 2503 NewTL.setNameLoc(TL.getNameLoc()); 2504 2505 return Result; 2506} 2507 2508template<typename Derived> 2509QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB, 2510 TypeOfExprTypeLoc TL) { 2511 TypeOfExprType *T = TL.getTypePtr(); 2512 2513 // typeof expressions are not potentially evaluated contexts 2514 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2515 2516 Sema::OwningExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); 2517 if (E.isInvalid()) 2518 return QualType(); 2519 2520 QualType Result = TL.getType(); 2521 if (getDerived().AlwaysRebuild() || 2522 E.get() != T->getUnderlyingExpr()) { 2523 Result = getDerived().RebuildTypeOfExprType(move(E)); 2524 if (Result.isNull()) 2525 return QualType(); 2526 } 2527 else E.take(); 2528 2529 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result); 2530 NewTL.setNameLoc(TL.getNameLoc()); 2531 2532 return Result; 2533} 2534 2535template<typename Derived> 2536QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB, 2537 TypeOfTypeLoc TL) { 2538 TypeOfType *T = TL.getTypePtr(); 2539 2540 // FIXME: should be an inner type, or at least have a DeclaratorInfo. 2541 QualType Underlying = getDerived().TransformType(T->getUnderlyingType()); 2542 if (Underlying.isNull()) 2543 return QualType(); 2544 2545 QualType Result = TL.getType(); 2546 if (getDerived().AlwaysRebuild() || 2547 Underlying != T->getUnderlyingType()) { 2548 Result = getDerived().RebuildTypeOfType(Underlying); 2549 if (Result.isNull()) 2550 return QualType(); 2551 } 2552 2553 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result); 2554 NewTL.setNameLoc(TL.getNameLoc()); 2555 2556 return Result; 2557} 2558 2559template<typename Derived> 2560QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB, 2561 DecltypeTypeLoc TL) { 2562 DecltypeType *T = TL.getTypePtr(); 2563 2564 // decltype expressions are not potentially evaluated contexts 2565 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2566 2567 Sema::OwningExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); 2568 if (E.isInvalid()) 2569 return QualType(); 2570 2571 QualType Result = TL.getType(); 2572 if (getDerived().AlwaysRebuild() || 2573 E.get() != T->getUnderlyingExpr()) { 2574 Result = getDerived().RebuildDecltypeType(move(E)); 2575 if (Result.isNull()) 2576 return QualType(); 2577 } 2578 else E.take(); 2579 2580 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result); 2581 NewTL.setNameLoc(TL.getNameLoc()); 2582 2583 return Result; 2584} 2585 2586template<typename Derived> 2587QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB, 2588 RecordTypeLoc TL) { 2589 RecordType *T = TL.getTypePtr(); 2590 RecordDecl *Record 2591 = cast_or_null<RecordDecl>(getDerived().TransformDecl(T->getDecl())); 2592 if (!Record) 2593 return QualType(); 2594 2595 QualType Result = TL.getType(); 2596 if (getDerived().AlwaysRebuild() || 2597 Record != T->getDecl()) { 2598 Result = getDerived().RebuildRecordType(Record); 2599 if (Result.isNull()) 2600 return QualType(); 2601 } 2602 2603 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result); 2604 NewTL.setNameLoc(TL.getNameLoc()); 2605 2606 return Result; 2607} 2608 2609template<typename Derived> 2610QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB, 2611 EnumTypeLoc TL) { 2612 EnumType *T = TL.getTypePtr(); 2613 EnumDecl *Enum 2614 = cast_or_null<EnumDecl>(getDerived().TransformDecl(T->getDecl())); 2615 if (!Enum) 2616 return QualType(); 2617 2618 QualType Result = TL.getType(); 2619 if (getDerived().AlwaysRebuild() || 2620 Enum != T->getDecl()) { 2621 Result = getDerived().RebuildEnumType(Enum); 2622 if (Result.isNull()) 2623 return QualType(); 2624 } 2625 2626 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result); 2627 NewTL.setNameLoc(TL.getNameLoc()); 2628 2629 return Result; 2630} 2631 2632template <typename Derived> 2633QualType TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB, 2634 ElaboratedTypeLoc TL) { 2635 ElaboratedType *T = TL.getTypePtr(); 2636 2637 // FIXME: this should be a nested type. 2638 QualType Underlying = getDerived().TransformType(T->getUnderlyingType()); 2639 if (Underlying.isNull()) 2640 return QualType(); 2641 2642 QualType Result = TL.getType(); 2643 if (getDerived().AlwaysRebuild() || 2644 Underlying != T->getUnderlyingType()) { 2645 Result = getDerived().RebuildElaboratedType(Underlying, T->getTagKind()); 2646 if (Result.isNull()) 2647 return QualType(); 2648 } 2649 2650 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 2651 NewTL.setNameLoc(TL.getNameLoc()); 2652 2653 return Result; 2654} 2655 2656 2657template<typename Derived> 2658QualType TreeTransform<Derived>::TransformTemplateTypeParmType( 2659 TypeLocBuilder &TLB, 2660 TemplateTypeParmTypeLoc TL) { 2661 return TransformTypeSpecType(TLB, TL); 2662} 2663 2664template<typename Derived> 2665QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType( 2666 TypeLocBuilder &TLB, 2667 SubstTemplateTypeParmTypeLoc TL) { 2668 return TransformTypeSpecType(TLB, TL); 2669} 2670 2671template<typename Derived> 2672inline QualType 2673TreeTransform<Derived>::TransformTemplateSpecializationType( 2674 TypeLocBuilder &TLB, 2675 TemplateSpecializationTypeLoc TL) { 2676 // TODO: figure out how make this work with an ObjectType. 2677 QualType Result 2678 = TransformTemplateSpecializationType(TL.getTypePtr(), QualType()); 2679 if (Result.isNull()) 2680 return QualType(); 2681 2682 TemplateSpecializationTypeLoc NewTL 2683 = TLB.push<TemplateSpecializationTypeLoc>(Result); 2684 NewTL.setNameLoc(TL.getNameLoc()); 2685 2686 return Result; 2687} 2688 2689template<typename Derived> 2690QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 2691 const TemplateSpecializationType *T, 2692 QualType ObjectType) { 2693 TemplateName Template 2694 = getDerived().TransformTemplateName(T->getTemplateName(), ObjectType); 2695 if (Template.isNull()) 2696 return QualType(); 2697 2698 llvm::SmallVector<TemplateArgument, 4> NewTemplateArgs; 2699 NewTemplateArgs.reserve(T->getNumArgs()); 2700 for (TemplateSpecializationType::iterator Arg = T->begin(), ArgEnd = T->end(); 2701 Arg != ArgEnd; ++Arg) { 2702 TemplateArgument NewArg = getDerived().TransformTemplateArgument(*Arg); 2703 if (NewArg.isNull()) 2704 return QualType(); 2705 2706 NewTemplateArgs.push_back(NewArg); 2707 } 2708 2709 // FIXME: early abort if all of the template arguments and such are the 2710 // same. 2711 2712 // FIXME: We're missing the locations of the template name, '<', and '>'. 2713 return getDerived().RebuildTemplateSpecializationType(Template, 2714 NewTemplateArgs.data(), 2715 NewTemplateArgs.size()); 2716} 2717 2718template<typename Derived> 2719QualType 2720TreeTransform<Derived>::TransformQualifiedNameType(TypeLocBuilder &TLB, 2721 QualifiedNameTypeLoc TL) { 2722 QualifiedNameType *T = TL.getTypePtr(); 2723 NestedNameSpecifier *NNS 2724 = getDerived().TransformNestedNameSpecifier(T->getQualifier(), 2725 SourceRange()); 2726 if (!NNS) 2727 return QualType(); 2728 2729 QualType Named = getDerived().TransformType(T->getNamedType()); 2730 if (Named.isNull()) 2731 return QualType(); 2732 2733 QualType Result = TL.getType(); 2734 if (getDerived().AlwaysRebuild() || 2735 NNS != T->getQualifier() || 2736 Named != T->getNamedType()) { 2737 Result = getDerived().RebuildQualifiedNameType(NNS, Named); 2738 if (Result.isNull()) 2739 return QualType(); 2740 } 2741 2742 QualifiedNameTypeLoc NewTL = TLB.push<QualifiedNameTypeLoc>(Result); 2743 NewTL.setNameLoc(TL.getNameLoc()); 2744 2745 return Result; 2746} 2747 2748template<typename Derived> 2749QualType TreeTransform<Derived>::TransformTypenameType(TypeLocBuilder &TLB, 2750 TypenameTypeLoc TL) { 2751 TypenameType *T = TL.getTypePtr(); 2752 NestedNameSpecifier *NNS 2753 = getDerived().TransformNestedNameSpecifier(T->getQualifier(), 2754 SourceRange(/*FIXME:*/getDerived().getBaseLocation())); 2755 if (!NNS) 2756 return QualType(); 2757 2758 QualType Result; 2759 2760 if (const TemplateSpecializationType *TemplateId = T->getTemplateId()) { 2761 QualType NewTemplateId 2762 = getDerived().TransformType(QualType(TemplateId, 0)); 2763 if (NewTemplateId.isNull()) 2764 return QualType(); 2765 2766 if (!getDerived().AlwaysRebuild() && 2767 NNS == T->getQualifier() && 2768 NewTemplateId == QualType(TemplateId, 0)) 2769 return QualType(T, 0); 2770 2771 Result = getDerived().RebuildTypenameType(NNS, NewTemplateId); 2772 } else { 2773 Result = getDerived().RebuildTypenameType(NNS, T->getIdentifier()); 2774 } 2775 if (Result.isNull()) 2776 return QualType(); 2777 2778 TypenameTypeLoc NewTL = TLB.push<TypenameTypeLoc>(Result); 2779 NewTL.setNameLoc(TL.getNameLoc()); 2780 2781 return Result; 2782} 2783 2784template<typename Derived> 2785QualType 2786TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB, 2787 ObjCInterfaceTypeLoc TL) { 2788 assert(false && "TransformObjCInterfaceType unimplemented"); 2789 return QualType(); 2790} 2791 2792template<typename Derived> 2793QualType 2794TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB, 2795 ObjCObjectPointerTypeLoc TL) { 2796 assert(false && "TransformObjCObjectPointerType unimplemented"); 2797 return QualType(); 2798} 2799 2800//===----------------------------------------------------------------------===// 2801// Statement transformation 2802//===----------------------------------------------------------------------===// 2803template<typename Derived> 2804Sema::OwningStmtResult 2805TreeTransform<Derived>::TransformNullStmt(NullStmt *S) { 2806 return SemaRef.Owned(S->Retain()); 2807} 2808 2809template<typename Derived> 2810Sema::OwningStmtResult 2811TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) { 2812 return getDerived().TransformCompoundStmt(S, false); 2813} 2814 2815template<typename Derived> 2816Sema::OwningStmtResult 2817TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S, 2818 bool IsStmtExpr) { 2819 bool SubStmtChanged = false; 2820 ASTOwningVector<&ActionBase::DeleteStmt> Statements(getSema()); 2821 for (CompoundStmt::body_iterator B = S->body_begin(), BEnd = S->body_end(); 2822 B != BEnd; ++B) { 2823 OwningStmtResult Result = getDerived().TransformStmt(*B); 2824 if (Result.isInvalid()) 2825 return getSema().StmtError(); 2826 2827 SubStmtChanged = SubStmtChanged || Result.get() != *B; 2828 Statements.push_back(Result.takeAs<Stmt>()); 2829 } 2830 2831 if (!getDerived().AlwaysRebuild() && 2832 !SubStmtChanged) 2833 return SemaRef.Owned(S->Retain()); 2834 2835 return getDerived().RebuildCompoundStmt(S->getLBracLoc(), 2836 move_arg(Statements), 2837 S->getRBracLoc(), 2838 IsStmtExpr); 2839} 2840 2841template<typename Derived> 2842Sema::OwningStmtResult 2843TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) { 2844 // The case value expressions are not potentially evaluated. 2845 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2846 2847 // Transform the left-hand case value. 2848 OwningExprResult LHS = getDerived().TransformExpr(S->getLHS()); 2849 if (LHS.isInvalid()) 2850 return SemaRef.StmtError(); 2851 2852 // Transform the right-hand case value (for the GNU case-range extension). 2853 OwningExprResult RHS = getDerived().TransformExpr(S->getRHS()); 2854 if (RHS.isInvalid()) 2855 return SemaRef.StmtError(); 2856 2857 // Build the case statement. 2858 // Case statements are always rebuilt so that they will attached to their 2859 // transformed switch statement. 2860 OwningStmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(), 2861 move(LHS), 2862 S->getEllipsisLoc(), 2863 move(RHS), 2864 S->getColonLoc()); 2865 if (Case.isInvalid()) 2866 return SemaRef.StmtError(); 2867 2868 // Transform the statement following the case 2869 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 2870 if (SubStmt.isInvalid()) 2871 return SemaRef.StmtError(); 2872 2873 // Attach the body to the case statement 2874 return getDerived().RebuildCaseStmtBody(move(Case), move(SubStmt)); 2875} 2876 2877template<typename Derived> 2878Sema::OwningStmtResult 2879TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) { 2880 // Transform the statement following the default case 2881 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 2882 if (SubStmt.isInvalid()) 2883 return SemaRef.StmtError(); 2884 2885 // Default statements are always rebuilt 2886 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(), 2887 move(SubStmt)); 2888} 2889 2890template<typename Derived> 2891Sema::OwningStmtResult 2892TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) { 2893 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 2894 if (SubStmt.isInvalid()) 2895 return SemaRef.StmtError(); 2896 2897 // FIXME: Pass the real colon location in. 2898 SourceLocation ColonLoc = SemaRef.PP.getLocForEndOfToken(S->getIdentLoc()); 2899 return getDerived().RebuildLabelStmt(S->getIdentLoc(), S->getID(), ColonLoc, 2900 move(SubStmt)); 2901} 2902 2903template<typename Derived> 2904Sema::OwningStmtResult 2905TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { 2906 // Transform the condition 2907 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 2908 if (Cond.isInvalid()) 2909 return SemaRef.StmtError(); 2910 2911 Sema::FullExprArg FullCond(getSema().FullExpr(Cond)); 2912 2913 // Transform the "then" branch. 2914 OwningStmtResult Then = getDerived().TransformStmt(S->getThen()); 2915 if (Then.isInvalid()) 2916 return SemaRef.StmtError(); 2917 2918 // Transform the "else" branch. 2919 OwningStmtResult Else = getDerived().TransformStmt(S->getElse()); 2920 if (Else.isInvalid()) 2921 return SemaRef.StmtError(); 2922 2923 if (!getDerived().AlwaysRebuild() && 2924 FullCond->get() == S->getCond() && 2925 Then.get() == S->getThen() && 2926 Else.get() == S->getElse()) 2927 return SemaRef.Owned(S->Retain()); 2928 2929 return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, move(Then), 2930 S->getElseLoc(), move(Else)); 2931} 2932 2933template<typename Derived> 2934Sema::OwningStmtResult 2935TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) { 2936 // Transform the condition. 2937 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 2938 if (Cond.isInvalid()) 2939 return SemaRef.StmtError(); 2940 2941 // Rebuild the switch statement. 2942 OwningStmtResult Switch = getDerived().RebuildSwitchStmtStart(move(Cond)); 2943 if (Switch.isInvalid()) 2944 return SemaRef.StmtError(); 2945 2946 // Transform the body of the switch statement. 2947 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 2948 if (Body.isInvalid()) 2949 return SemaRef.StmtError(); 2950 2951 // Complete the switch statement. 2952 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), move(Switch), 2953 move(Body)); 2954} 2955 2956template<typename Derived> 2957Sema::OwningStmtResult 2958TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) { 2959 // Transform the condition 2960 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 2961 if (Cond.isInvalid()) 2962 return SemaRef.StmtError(); 2963 2964 Sema::FullExprArg FullCond(getSema().FullExpr(Cond)); 2965 2966 // Transform the body 2967 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 2968 if (Body.isInvalid()) 2969 return SemaRef.StmtError(); 2970 2971 if (!getDerived().AlwaysRebuild() && 2972 FullCond->get() == S->getCond() && 2973 Body.get() == S->getBody()) 2974 return SemaRef.Owned(S->Retain()); 2975 2976 return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond, move(Body)); 2977} 2978 2979template<typename Derived> 2980Sema::OwningStmtResult 2981TreeTransform<Derived>::TransformDoStmt(DoStmt *S) { 2982 // Transform the condition 2983 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 2984 if (Cond.isInvalid()) 2985 return SemaRef.StmtError(); 2986 2987 // Transform the body 2988 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 2989 if (Body.isInvalid()) 2990 return SemaRef.StmtError(); 2991 2992 if (!getDerived().AlwaysRebuild() && 2993 Cond.get() == S->getCond() && 2994 Body.get() == S->getBody()) 2995 return SemaRef.Owned(S->Retain()); 2996 2997 return getDerived().RebuildDoStmt(S->getDoLoc(), move(Body), S->getWhileLoc(), 2998 /*FIXME:*/S->getWhileLoc(), move(Cond), 2999 S->getRParenLoc()); 3000} 3001 3002template<typename Derived> 3003Sema::OwningStmtResult 3004TreeTransform<Derived>::TransformForStmt(ForStmt *S) { 3005 // Transform the initialization statement 3006 OwningStmtResult Init = getDerived().TransformStmt(S->getInit()); 3007 if (Init.isInvalid()) 3008 return SemaRef.StmtError(); 3009 3010 // Transform the condition 3011 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 3012 if (Cond.isInvalid()) 3013 return SemaRef.StmtError(); 3014 3015 // Transform the increment 3016 OwningExprResult Inc = getDerived().TransformExpr(S->getInc()); 3017 if (Inc.isInvalid()) 3018 return SemaRef.StmtError(); 3019 3020 // Transform the body 3021 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3022 if (Body.isInvalid()) 3023 return SemaRef.StmtError(); 3024 3025 if (!getDerived().AlwaysRebuild() && 3026 Init.get() == S->getInit() && 3027 Cond.get() == S->getCond() && 3028 Inc.get() == S->getInc() && 3029 Body.get() == S->getBody()) 3030 return SemaRef.Owned(S->Retain()); 3031 3032 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(), 3033 move(Init), move(Cond), move(Inc), 3034 S->getRParenLoc(), move(Body)); 3035} 3036 3037template<typename Derived> 3038Sema::OwningStmtResult 3039TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) { 3040 // Goto statements must always be rebuilt, to resolve the label. 3041 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(), 3042 S->getLabel()); 3043} 3044 3045template<typename Derived> 3046Sema::OwningStmtResult 3047TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) { 3048 OwningExprResult Target = getDerived().TransformExpr(S->getTarget()); 3049 if (Target.isInvalid()) 3050 return SemaRef.StmtError(); 3051 3052 if (!getDerived().AlwaysRebuild() && 3053 Target.get() == S->getTarget()) 3054 return SemaRef.Owned(S->Retain()); 3055 3056 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(), 3057 move(Target)); 3058} 3059 3060template<typename Derived> 3061Sema::OwningStmtResult 3062TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) { 3063 return SemaRef.Owned(S->Retain()); 3064} 3065 3066template<typename Derived> 3067Sema::OwningStmtResult 3068TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) { 3069 return SemaRef.Owned(S->Retain()); 3070} 3071 3072template<typename Derived> 3073Sema::OwningStmtResult 3074TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) { 3075 Sema::OwningExprResult Result = getDerived().TransformExpr(S->getRetValue()); 3076 if (Result.isInvalid()) 3077 return SemaRef.StmtError(); 3078 3079 // FIXME: We always rebuild the return statement because there is no way 3080 // to tell whether the return type of the function has changed. 3081 return getDerived().RebuildReturnStmt(S->getReturnLoc(), move(Result)); 3082} 3083 3084template<typename Derived> 3085Sema::OwningStmtResult 3086TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) { 3087 bool DeclChanged = false; 3088 llvm::SmallVector<Decl *, 4> Decls; 3089 for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end(); 3090 D != DEnd; ++D) { 3091 Decl *Transformed = getDerived().TransformDefinition(*D); 3092 if (!Transformed) 3093 return SemaRef.StmtError(); 3094 3095 if (Transformed != *D) 3096 DeclChanged = true; 3097 3098 Decls.push_back(Transformed); 3099 } 3100 3101 if (!getDerived().AlwaysRebuild() && !DeclChanged) 3102 return SemaRef.Owned(S->Retain()); 3103 3104 return getDerived().RebuildDeclStmt(Decls.data(), Decls.size(), 3105 S->getStartLoc(), S->getEndLoc()); 3106} 3107 3108template<typename Derived> 3109Sema::OwningStmtResult 3110TreeTransform<Derived>::TransformSwitchCase(SwitchCase *S) { 3111 assert(false && "SwitchCase is abstract and cannot be transformed"); 3112 return SemaRef.Owned(S->Retain()); 3113} 3114 3115template<typename Derived> 3116Sema::OwningStmtResult 3117TreeTransform<Derived>::TransformAsmStmt(AsmStmt *S) { 3118 // FIXME: Implement! 3119 assert(false && "Inline assembly cannot be transformed"); 3120 return SemaRef.Owned(S->Retain()); 3121} 3122 3123 3124template<typename Derived> 3125Sema::OwningStmtResult 3126TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) { 3127 // FIXME: Implement this 3128 assert(false && "Cannot transform an Objective-C @try statement"); 3129 return SemaRef.Owned(S->Retain()); 3130} 3131 3132template<typename Derived> 3133Sema::OwningStmtResult 3134TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) { 3135 // FIXME: Implement this 3136 assert(false && "Cannot transform an Objective-C @catch statement"); 3137 return SemaRef.Owned(S->Retain()); 3138} 3139 3140template<typename Derived> 3141Sema::OwningStmtResult 3142TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 3143 // FIXME: Implement this 3144 assert(false && "Cannot transform an Objective-C @finally statement"); 3145 return SemaRef.Owned(S->Retain()); 3146} 3147 3148template<typename Derived> 3149Sema::OwningStmtResult 3150TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) { 3151 // FIXME: Implement this 3152 assert(false && "Cannot transform an Objective-C @throw statement"); 3153 return SemaRef.Owned(S->Retain()); 3154} 3155 3156template<typename Derived> 3157Sema::OwningStmtResult 3158TreeTransform<Derived>::TransformObjCAtSynchronizedStmt( 3159 ObjCAtSynchronizedStmt *S) { 3160 // FIXME: Implement this 3161 assert(false && "Cannot transform an Objective-C @synchronized statement"); 3162 return SemaRef.Owned(S->Retain()); 3163} 3164 3165template<typename Derived> 3166Sema::OwningStmtResult 3167TreeTransform<Derived>::TransformObjCForCollectionStmt( 3168 ObjCForCollectionStmt *S) { 3169 // FIXME: Implement this 3170 assert(false && "Cannot transform an Objective-C for-each statement"); 3171 return SemaRef.Owned(S->Retain()); 3172} 3173 3174 3175template<typename Derived> 3176Sema::OwningStmtResult 3177TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) { 3178 // Transform the exception declaration, if any. 3179 VarDecl *Var = 0; 3180 if (S->getExceptionDecl()) { 3181 VarDecl *ExceptionDecl = S->getExceptionDecl(); 3182 TemporaryBase Rebase(*this, ExceptionDecl->getLocation(), 3183 ExceptionDecl->getDeclName()); 3184 3185 QualType T = getDerived().TransformType(ExceptionDecl->getType()); 3186 if (T.isNull()) 3187 return SemaRef.StmtError(); 3188 3189 Var = getDerived().RebuildExceptionDecl(ExceptionDecl, 3190 T, 3191 ExceptionDecl->getDeclaratorInfo(), 3192 ExceptionDecl->getIdentifier(), 3193 ExceptionDecl->getLocation(), 3194 /*FIXME: Inaccurate*/ 3195 SourceRange(ExceptionDecl->getLocation())); 3196 if (!Var || Var->isInvalidDecl()) { 3197 if (Var) 3198 Var->Destroy(SemaRef.Context); 3199 return SemaRef.StmtError(); 3200 } 3201 } 3202 3203 // Transform the actual exception handler. 3204 OwningStmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock()); 3205 if (Handler.isInvalid()) { 3206 if (Var) 3207 Var->Destroy(SemaRef.Context); 3208 return SemaRef.StmtError(); 3209 } 3210 3211 if (!getDerived().AlwaysRebuild() && 3212 !Var && 3213 Handler.get() == S->getHandlerBlock()) 3214 return SemaRef.Owned(S->Retain()); 3215 3216 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), 3217 Var, 3218 move(Handler)); 3219} 3220 3221template<typename Derived> 3222Sema::OwningStmtResult 3223TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) { 3224 // Transform the try block itself. 3225 OwningStmtResult TryBlock 3226 = getDerived().TransformCompoundStmt(S->getTryBlock()); 3227 if (TryBlock.isInvalid()) 3228 return SemaRef.StmtError(); 3229 3230 // Transform the handlers. 3231 bool HandlerChanged = false; 3232 ASTOwningVector<&ActionBase::DeleteStmt> Handlers(SemaRef); 3233 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) { 3234 OwningStmtResult Handler 3235 = getDerived().TransformCXXCatchStmt(S->getHandler(I)); 3236 if (Handler.isInvalid()) 3237 return SemaRef.StmtError(); 3238 3239 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I); 3240 Handlers.push_back(Handler.takeAs<Stmt>()); 3241 } 3242 3243 if (!getDerived().AlwaysRebuild() && 3244 TryBlock.get() == S->getTryBlock() && 3245 !HandlerChanged) 3246 return SemaRef.Owned(S->Retain()); 3247 3248 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), move(TryBlock), 3249 move_arg(Handlers)); 3250} 3251 3252//===----------------------------------------------------------------------===// 3253// Expression transformation 3254//===----------------------------------------------------------------------===// 3255template<typename Derived> 3256Sema::OwningExprResult 3257TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) { 3258 return SemaRef.Owned(E->Retain()); 3259} 3260 3261template<typename Derived> 3262Sema::OwningExprResult 3263TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) { 3264 NestedNameSpecifier *Qualifier = 0; 3265 if (E->getQualifier()) { 3266 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 3267 E->getQualifierRange()); 3268 if (!Qualifier) 3269 return SemaRef.ExprError(); 3270 } 3271 3272 NamedDecl *ND 3273 = dyn_cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getDecl())); 3274 if (!ND) 3275 return SemaRef.ExprError(); 3276 3277 if (!getDerived().AlwaysRebuild() && 3278 Qualifier == E->getQualifier() && 3279 ND == E->getDecl() && 3280 !E->hasExplicitTemplateArgumentList()) 3281 return SemaRef.Owned(E->Retain()); 3282 3283 // FIXME: We're losing the explicit template arguments in this transformation. 3284 3285 llvm::SmallVector<TemplateArgument, 4> TransArgs; 3286 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 3287 TemplateArgument TransArg 3288 = getDerived().TransformTemplateArgument(E->getTemplateArgs()[I]); 3289 if (TransArg.isNull()) 3290 return SemaRef.ExprError(); 3291 3292 TransArgs.push_back(TransArg); 3293 } 3294 3295 // FIXME: Pass the qualifier/qualifier range along. 3296 return getDerived().RebuildDeclRefExpr(Qualifier, E->getQualifierRange(), 3297 ND, E->getLocation()); 3298} 3299 3300template<typename Derived> 3301Sema::OwningExprResult 3302TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) { 3303 return SemaRef.Owned(E->Retain()); 3304} 3305 3306template<typename Derived> 3307Sema::OwningExprResult 3308TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) { 3309 return SemaRef.Owned(E->Retain()); 3310} 3311 3312template<typename Derived> 3313Sema::OwningExprResult 3314TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) { 3315 return SemaRef.Owned(E->Retain()); 3316} 3317 3318template<typename Derived> 3319Sema::OwningExprResult 3320TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) { 3321 return SemaRef.Owned(E->Retain()); 3322} 3323 3324template<typename Derived> 3325Sema::OwningExprResult 3326TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) { 3327 return SemaRef.Owned(E->Retain()); 3328} 3329 3330template<typename Derived> 3331Sema::OwningExprResult 3332TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) { 3333 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 3334 if (SubExpr.isInvalid()) 3335 return SemaRef.ExprError(); 3336 3337 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 3338 return SemaRef.Owned(E->Retain()); 3339 3340 return getDerived().RebuildParenExpr(move(SubExpr), E->getLParen(), 3341 E->getRParen()); 3342} 3343 3344template<typename Derived> 3345Sema::OwningExprResult 3346TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) { 3347 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 3348 if (SubExpr.isInvalid()) 3349 return SemaRef.ExprError(); 3350 3351 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 3352 return SemaRef.Owned(E->Retain()); 3353 3354 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(), 3355 E->getOpcode(), 3356 move(SubExpr)); 3357} 3358 3359template<typename Derived> 3360Sema::OwningExprResult 3361TreeTransform<Derived>::TransformSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { 3362 if (E->isArgumentType()) { 3363 QualType T = getDerived().TransformType(E->getArgumentType()); 3364 if (T.isNull()) 3365 return SemaRef.ExprError(); 3366 3367 if (!getDerived().AlwaysRebuild() && T == E->getArgumentType()) 3368 return SemaRef.Owned(E->Retain()); 3369 3370 return getDerived().RebuildSizeOfAlignOf(T, E->getOperatorLoc(), 3371 E->isSizeOf(), 3372 E->getSourceRange()); 3373 } 3374 3375 Sema::OwningExprResult SubExpr(SemaRef); 3376 { 3377 // C++0x [expr.sizeof]p1: 3378 // The operand is either an expression, which is an unevaluated operand 3379 // [...] 3380 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 3381 3382 SubExpr = getDerived().TransformExpr(E->getArgumentExpr()); 3383 if (SubExpr.isInvalid()) 3384 return SemaRef.ExprError(); 3385 3386 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr()) 3387 return SemaRef.Owned(E->Retain()); 3388 } 3389 3390 return getDerived().RebuildSizeOfAlignOf(move(SubExpr), E->getOperatorLoc(), 3391 E->isSizeOf(), 3392 E->getSourceRange()); 3393} 3394 3395template<typename Derived> 3396Sema::OwningExprResult 3397TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) { 3398 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 3399 if (LHS.isInvalid()) 3400 return SemaRef.ExprError(); 3401 3402 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 3403 if (RHS.isInvalid()) 3404 return SemaRef.ExprError(); 3405 3406 3407 if (!getDerived().AlwaysRebuild() && 3408 LHS.get() == E->getLHS() && 3409 RHS.get() == E->getRHS()) 3410 return SemaRef.Owned(E->Retain()); 3411 3412 return getDerived().RebuildArraySubscriptExpr(move(LHS), 3413 /*FIXME:*/E->getLHS()->getLocStart(), 3414 move(RHS), 3415 E->getRBracketLoc()); 3416} 3417 3418template<typename Derived> 3419Sema::OwningExprResult 3420TreeTransform<Derived>::TransformCallExpr(CallExpr *E) { 3421 // Transform the callee. 3422 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee()); 3423 if (Callee.isInvalid()) 3424 return SemaRef.ExprError(); 3425 3426 // Transform arguments. 3427 bool ArgChanged = false; 3428 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 3429 llvm::SmallVector<SourceLocation, 4> FakeCommaLocs; 3430 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) { 3431 OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I)); 3432 if (Arg.isInvalid()) 3433 return SemaRef.ExprError(); 3434 3435 // FIXME: Wrong source location information for the ','. 3436 FakeCommaLocs.push_back( 3437 SemaRef.PP.getLocForEndOfToken(E->getArg(I)->getSourceRange().getEnd())); 3438 3439 ArgChanged = ArgChanged || Arg.get() != E->getArg(I); 3440 Args.push_back(Arg.takeAs<Expr>()); 3441 } 3442 3443 if (!getDerived().AlwaysRebuild() && 3444 Callee.get() == E->getCallee() && 3445 !ArgChanged) 3446 return SemaRef.Owned(E->Retain()); 3447 3448 // FIXME: Wrong source location information for the '('. 3449 SourceLocation FakeLParenLoc 3450 = ((Expr *)Callee.get())->getSourceRange().getBegin(); 3451 return getDerived().RebuildCallExpr(move(Callee), FakeLParenLoc, 3452 move_arg(Args), 3453 FakeCommaLocs.data(), 3454 E->getRParenLoc()); 3455} 3456 3457template<typename Derived> 3458Sema::OwningExprResult 3459TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) { 3460 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 3461 if (Base.isInvalid()) 3462 return SemaRef.ExprError(); 3463 3464 NestedNameSpecifier *Qualifier = 0; 3465 if (E->hasQualifier()) { 3466 Qualifier 3467 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 3468 E->getQualifierRange()); 3469 if (Qualifier == 0) 3470 return SemaRef.ExprError(); 3471 } 3472 3473 NamedDecl *Member 3474 = cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getMemberDecl())); 3475 if (!Member) 3476 return SemaRef.ExprError(); 3477 3478 if (!getDerived().AlwaysRebuild() && 3479 Base.get() == E->getBase() && 3480 Qualifier == E->getQualifier() && 3481 Member == E->getMemberDecl()) 3482 return SemaRef.Owned(E->Retain()); 3483 3484 // FIXME: Bogus source location for the operator 3485 SourceLocation FakeOperatorLoc 3486 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd()); 3487 3488 return getDerived().RebuildMemberExpr(move(Base), FakeOperatorLoc, 3489 E->isArrow(), 3490 Qualifier, 3491 E->getQualifierRange(), 3492 E->getMemberLoc(), 3493 Member); 3494} 3495 3496template<typename Derived> 3497Sema::OwningExprResult 3498TreeTransform<Derived>::TransformCastExpr(CastExpr *E) { 3499 assert(false && "Cannot transform abstract class"); 3500 return SemaRef.Owned(E->Retain()); 3501} 3502 3503template<typename Derived> 3504Sema::OwningExprResult 3505TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) { 3506 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 3507 if (LHS.isInvalid()) 3508 return SemaRef.ExprError(); 3509 3510 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 3511 if (RHS.isInvalid()) 3512 return SemaRef.ExprError(); 3513 3514 if (!getDerived().AlwaysRebuild() && 3515 LHS.get() == E->getLHS() && 3516 RHS.get() == E->getRHS()) 3517 return SemaRef.Owned(E->Retain()); 3518 3519 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(), 3520 move(LHS), move(RHS)); 3521} 3522 3523template<typename Derived> 3524Sema::OwningExprResult 3525TreeTransform<Derived>::TransformCompoundAssignOperator( 3526 CompoundAssignOperator *E) { 3527 return getDerived().TransformBinaryOperator(E); 3528} 3529 3530template<typename Derived> 3531Sema::OwningExprResult 3532TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) { 3533 OwningExprResult Cond = getDerived().TransformExpr(E->getCond()); 3534 if (Cond.isInvalid()) 3535 return SemaRef.ExprError(); 3536 3537 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 3538 if (LHS.isInvalid()) 3539 return SemaRef.ExprError(); 3540 3541 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 3542 if (RHS.isInvalid()) 3543 return SemaRef.ExprError(); 3544 3545 if (!getDerived().AlwaysRebuild() && 3546 Cond.get() == E->getCond() && 3547 LHS.get() == E->getLHS() && 3548 RHS.get() == E->getRHS()) 3549 return SemaRef.Owned(E->Retain()); 3550 3551 return getDerived().RebuildConditionalOperator(move(Cond), 3552 E->getQuestionLoc(), 3553 move(LHS), 3554 E->getColonLoc(), 3555 move(RHS)); 3556} 3557 3558template<typename Derived> 3559Sema::OwningExprResult 3560TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) { 3561 QualType T = getDerived().TransformType(E->getType()); 3562 if (T.isNull()) 3563 return SemaRef.ExprError(); 3564 3565 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 3566 if (SubExpr.isInvalid()) 3567 return SemaRef.ExprError(); 3568 3569 if (!getDerived().AlwaysRebuild() && 3570 T == E->getType() && 3571 SubExpr.get() == E->getSubExpr()) 3572 return SemaRef.Owned(E->Retain()); 3573 3574 return getDerived().RebuildImplicitCastExpr(T, E->getCastKind(), 3575 move(SubExpr), 3576 E->isLvalueCast()); 3577} 3578 3579template<typename Derived> 3580Sema::OwningExprResult 3581TreeTransform<Derived>::TransformExplicitCastExpr(ExplicitCastExpr *E) { 3582 assert(false && "Cannot transform abstract class"); 3583 return SemaRef.Owned(E->Retain()); 3584} 3585 3586template<typename Derived> 3587Sema::OwningExprResult 3588TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) { 3589 QualType T; 3590 { 3591 // FIXME: Source location isn't quite accurate. 3592 SourceLocation TypeStartLoc 3593 = SemaRef.PP.getLocForEndOfToken(E->getLParenLoc()); 3594 TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName()); 3595 3596 T = getDerived().TransformType(E->getTypeAsWritten()); 3597 if (T.isNull()) 3598 return SemaRef.ExprError(); 3599 } 3600 3601 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 3602 if (SubExpr.isInvalid()) 3603 return SemaRef.ExprError(); 3604 3605 if (!getDerived().AlwaysRebuild() && 3606 T == E->getTypeAsWritten() && 3607 SubExpr.get() == E->getSubExpr()) 3608 return SemaRef.Owned(E->Retain()); 3609 3610 return getDerived().RebuildCStyleCaseExpr(E->getLParenLoc(), T, 3611 E->getRParenLoc(), 3612 move(SubExpr)); 3613} 3614 3615template<typename Derived> 3616Sema::OwningExprResult 3617TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) { 3618 QualType T; 3619 { 3620 // FIXME: Source location isn't quite accurate. 3621 SourceLocation FakeTypeLoc 3622 = SemaRef.PP.getLocForEndOfToken(E->getLParenLoc()); 3623 TemporaryBase Rebase(*this, FakeTypeLoc, DeclarationName()); 3624 3625 T = getDerived().TransformType(E->getType()); 3626 if (T.isNull()) 3627 return SemaRef.ExprError(); 3628 } 3629 3630 OwningExprResult Init = getDerived().TransformExpr(E->getInitializer()); 3631 if (Init.isInvalid()) 3632 return SemaRef.ExprError(); 3633 3634 if (!getDerived().AlwaysRebuild() && 3635 T == E->getType() && 3636 Init.get() == E->getInitializer()) 3637 return SemaRef.Owned(E->Retain()); 3638 3639 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), T, 3640 /*FIXME:*/E->getInitializer()->getLocEnd(), 3641 move(Init)); 3642} 3643 3644template<typename Derived> 3645Sema::OwningExprResult 3646TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) { 3647 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 3648 if (Base.isInvalid()) 3649 return SemaRef.ExprError(); 3650 3651 if (!getDerived().AlwaysRebuild() && 3652 Base.get() == E->getBase()) 3653 return SemaRef.Owned(E->Retain()); 3654 3655 // FIXME: Bad source location 3656 SourceLocation FakeOperatorLoc 3657 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getLocEnd()); 3658 return getDerived().RebuildExtVectorElementExpr(move(Base), FakeOperatorLoc, 3659 E->getAccessorLoc(), 3660 E->getAccessor()); 3661} 3662 3663template<typename Derived> 3664Sema::OwningExprResult 3665TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) { 3666 bool InitChanged = false; 3667 3668 ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef); 3669 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) { 3670 OwningExprResult Init = getDerived().TransformExpr(E->getInit(I)); 3671 if (Init.isInvalid()) 3672 return SemaRef.ExprError(); 3673 3674 InitChanged = InitChanged || Init.get() != E->getInit(I); 3675 Inits.push_back(Init.takeAs<Expr>()); 3676 } 3677 3678 if (!getDerived().AlwaysRebuild() && !InitChanged) 3679 return SemaRef.Owned(E->Retain()); 3680 3681 return getDerived().RebuildInitList(E->getLBraceLoc(), move_arg(Inits), 3682 E->getRBraceLoc()); 3683} 3684 3685template<typename Derived> 3686Sema::OwningExprResult 3687TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { 3688 Designation Desig; 3689 3690 // transform the initializer value 3691 OwningExprResult Init = getDerived().TransformExpr(E->getInit()); 3692 if (Init.isInvalid()) 3693 return SemaRef.ExprError(); 3694 3695 // transform the designators. 3696 ASTOwningVector<&ActionBase::DeleteExpr, 4> ArrayExprs(SemaRef); 3697 bool ExprChanged = false; 3698 for (DesignatedInitExpr::designators_iterator D = E->designators_begin(), 3699 DEnd = E->designators_end(); 3700 D != DEnd; ++D) { 3701 if (D->isFieldDesignator()) { 3702 Desig.AddDesignator(Designator::getField(D->getFieldName(), 3703 D->getDotLoc(), 3704 D->getFieldLoc())); 3705 continue; 3706 } 3707 3708 if (D->isArrayDesignator()) { 3709 OwningExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D)); 3710 if (Index.isInvalid()) 3711 return SemaRef.ExprError(); 3712 3713 Desig.AddDesignator(Designator::getArray(Index.get(), 3714 D->getLBracketLoc())); 3715 3716 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D); 3717 ArrayExprs.push_back(Index.release()); 3718 continue; 3719 } 3720 3721 assert(D->isArrayRangeDesignator() && "New kind of designator?"); 3722 OwningExprResult Start 3723 = getDerived().TransformExpr(E->getArrayRangeStart(*D)); 3724 if (Start.isInvalid()) 3725 return SemaRef.ExprError(); 3726 3727 OwningExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D)); 3728 if (End.isInvalid()) 3729 return SemaRef.ExprError(); 3730 3731 Desig.AddDesignator(Designator::getArrayRange(Start.get(), 3732 End.get(), 3733 D->getLBracketLoc(), 3734 D->getEllipsisLoc())); 3735 3736 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) || 3737 End.get() != E->getArrayRangeEnd(*D); 3738 3739 ArrayExprs.push_back(Start.release()); 3740 ArrayExprs.push_back(End.release()); 3741 } 3742 3743 if (!getDerived().AlwaysRebuild() && 3744 Init.get() == E->getInit() && 3745 !ExprChanged) 3746 return SemaRef.Owned(E->Retain()); 3747 3748 return getDerived().RebuildDesignatedInitExpr(Desig, move_arg(ArrayExprs), 3749 E->getEqualOrColonLoc(), 3750 E->usesGNUSyntax(), move(Init)); 3751} 3752 3753template<typename Derived> 3754Sema::OwningExprResult 3755TreeTransform<Derived>::TransformImplicitValueInitExpr( 3756 ImplicitValueInitExpr *E) { 3757 QualType T = getDerived().TransformType(E->getType()); 3758 if (T.isNull()) 3759 return SemaRef.ExprError(); 3760 3761 if (!getDerived().AlwaysRebuild() && 3762 T == E->getType()) 3763 return SemaRef.Owned(E->Retain()); 3764 3765 return getDerived().RebuildImplicitValueInitExpr(T); 3766} 3767 3768template<typename Derived> 3769Sema::OwningExprResult 3770TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) { 3771 // FIXME: Do we want the type as written? 3772 QualType T; 3773 3774 { 3775 // FIXME: Source location isn't quite accurate. 3776 TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName()); 3777 T = getDerived().TransformType(E->getType()); 3778 if (T.isNull()) 3779 return SemaRef.ExprError(); 3780 } 3781 3782 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 3783 if (SubExpr.isInvalid()) 3784 return SemaRef.ExprError(); 3785 3786 if (!getDerived().AlwaysRebuild() && 3787 T == E->getType() && 3788 SubExpr.get() == E->getSubExpr()) 3789 return SemaRef.Owned(E->Retain()); 3790 3791 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), move(SubExpr), 3792 T, E->getRParenLoc()); 3793} 3794 3795template<typename Derived> 3796Sema::OwningExprResult 3797TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) { 3798 bool ArgumentChanged = false; 3799 ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef); 3800 for (unsigned I = 0, N = E->getNumExprs(); I != N; ++I) { 3801 OwningExprResult Init = getDerived().TransformExpr(E->getExpr(I)); 3802 if (Init.isInvalid()) 3803 return SemaRef.ExprError(); 3804 3805 ArgumentChanged = ArgumentChanged || Init.get() != E->getExpr(I); 3806 Inits.push_back(Init.takeAs<Expr>()); 3807 } 3808 3809 return getDerived().RebuildParenListExpr(E->getLParenLoc(), 3810 move_arg(Inits), 3811 E->getRParenLoc()); 3812} 3813 3814/// \brief Transform an address-of-label expression. 3815/// 3816/// By default, the transformation of an address-of-label expression always 3817/// rebuilds the expression, so that the label identifier can be resolved to 3818/// the corresponding label statement by semantic analysis. 3819template<typename Derived> 3820Sema::OwningExprResult 3821TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) { 3822 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(), 3823 E->getLabel()); 3824} 3825 3826template<typename Derived> 3827Sema::OwningExprResult TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) { 3828 OwningStmtResult SubStmt 3829 = getDerived().TransformCompoundStmt(E->getSubStmt(), true); 3830 if (SubStmt.isInvalid()) 3831 return SemaRef.ExprError(); 3832 3833 if (!getDerived().AlwaysRebuild() && 3834 SubStmt.get() == E->getSubStmt()) 3835 return SemaRef.Owned(E->Retain()); 3836 3837 return getDerived().RebuildStmtExpr(E->getLParenLoc(), 3838 move(SubStmt), 3839 E->getRParenLoc()); 3840} 3841 3842template<typename Derived> 3843Sema::OwningExprResult 3844TreeTransform<Derived>::TransformTypesCompatibleExpr(TypesCompatibleExpr *E) { 3845 QualType T1, T2; 3846 { 3847 // FIXME: Source location isn't quite accurate. 3848 TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName()); 3849 3850 T1 = getDerived().TransformType(E->getArgType1()); 3851 if (T1.isNull()) 3852 return SemaRef.ExprError(); 3853 3854 T2 = getDerived().TransformType(E->getArgType2()); 3855 if (T2.isNull()) 3856 return SemaRef.ExprError(); 3857 } 3858 3859 if (!getDerived().AlwaysRebuild() && 3860 T1 == E->getArgType1() && 3861 T2 == E->getArgType2()) 3862 return SemaRef.Owned(E->Retain()); 3863 3864 return getDerived().RebuildTypesCompatibleExpr(E->getBuiltinLoc(), 3865 T1, T2, E->getRParenLoc()); 3866} 3867 3868template<typename Derived> 3869Sema::OwningExprResult 3870TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) { 3871 OwningExprResult Cond = getDerived().TransformExpr(E->getCond()); 3872 if (Cond.isInvalid()) 3873 return SemaRef.ExprError(); 3874 3875 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 3876 if (LHS.isInvalid()) 3877 return SemaRef.ExprError(); 3878 3879 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 3880 if (RHS.isInvalid()) 3881 return SemaRef.ExprError(); 3882 3883 if (!getDerived().AlwaysRebuild() && 3884 Cond.get() == E->getCond() && 3885 LHS.get() == E->getLHS() && 3886 RHS.get() == E->getRHS()) 3887 return SemaRef.Owned(E->Retain()); 3888 3889 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(), 3890 move(Cond), move(LHS), move(RHS), 3891 E->getRParenLoc()); 3892} 3893 3894template<typename Derived> 3895Sema::OwningExprResult 3896TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) { 3897 return SemaRef.Owned(E->Retain()); 3898} 3899 3900template<typename Derived> 3901Sema::OwningExprResult 3902TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 3903 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee()); 3904 if (Callee.isInvalid()) 3905 return SemaRef.ExprError(); 3906 3907 OwningExprResult First = getDerived().TransformExpr(E->getArg(0)); 3908 if (First.isInvalid()) 3909 return SemaRef.ExprError(); 3910 3911 OwningExprResult Second(SemaRef); 3912 if (E->getNumArgs() == 2) { 3913 Second = getDerived().TransformExpr(E->getArg(1)); 3914 if (Second.isInvalid()) 3915 return SemaRef.ExprError(); 3916 } 3917 3918 if (!getDerived().AlwaysRebuild() && 3919 Callee.get() == E->getCallee() && 3920 First.get() == E->getArg(0) && 3921 (E->getNumArgs() != 2 || Second.get() == E->getArg(1))) 3922 return SemaRef.Owned(E->Retain()); 3923 3924 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(), 3925 E->getOperatorLoc(), 3926 move(Callee), 3927 move(First), 3928 move(Second)); 3929} 3930 3931template<typename Derived> 3932Sema::OwningExprResult 3933TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) { 3934 return getDerived().TransformCallExpr(E); 3935} 3936 3937template<typename Derived> 3938Sema::OwningExprResult 3939TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) { 3940 QualType ExplicitTy; 3941 { 3942 // FIXME: Source location isn't quite accurate. 3943 SourceLocation TypeStartLoc 3944 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc()); 3945 TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName()); 3946 3947 ExplicitTy = getDerived().TransformType(E->getTypeAsWritten()); 3948 if (ExplicitTy.isNull()) 3949 return SemaRef.ExprError(); 3950 } 3951 3952 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 3953 if (SubExpr.isInvalid()) 3954 return SemaRef.ExprError(); 3955 3956 if (!getDerived().AlwaysRebuild() && 3957 ExplicitTy == E->getTypeAsWritten() && 3958 SubExpr.get() == E->getSubExpr()) 3959 return SemaRef.Owned(E->Retain()); 3960 3961 // FIXME: Poor source location information here. 3962 SourceLocation FakeLAngleLoc 3963 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc()); 3964 SourceLocation FakeRAngleLoc = E->getSubExpr()->getSourceRange().getBegin(); 3965 SourceLocation FakeRParenLoc 3966 = SemaRef.PP.getLocForEndOfToken( 3967 E->getSubExpr()->getSourceRange().getEnd()); 3968 return getDerived().RebuildCXXNamedCastExpr(E->getOperatorLoc(), 3969 E->getStmtClass(), 3970 FakeLAngleLoc, 3971 ExplicitTy, 3972 FakeRAngleLoc, 3973 FakeRAngleLoc, 3974 move(SubExpr), 3975 FakeRParenLoc); 3976} 3977 3978template<typename Derived> 3979Sema::OwningExprResult 3980TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) { 3981 return getDerived().TransformCXXNamedCastExpr(E); 3982} 3983 3984template<typename Derived> 3985Sema::OwningExprResult 3986TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) { 3987 return getDerived().TransformCXXNamedCastExpr(E); 3988} 3989 3990template<typename Derived> 3991Sema::OwningExprResult 3992TreeTransform<Derived>::TransformCXXReinterpretCastExpr( 3993 CXXReinterpretCastExpr *E) { 3994 return getDerived().TransformCXXNamedCastExpr(E); 3995} 3996 3997template<typename Derived> 3998Sema::OwningExprResult 3999TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) { 4000 return getDerived().TransformCXXNamedCastExpr(E); 4001} 4002 4003template<typename Derived> 4004Sema::OwningExprResult 4005TreeTransform<Derived>::TransformCXXFunctionalCastExpr( 4006 CXXFunctionalCastExpr *E) { 4007 QualType ExplicitTy; 4008 { 4009 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 4010 4011 ExplicitTy = getDerived().TransformType(E->getTypeAsWritten()); 4012 if (ExplicitTy.isNull()) 4013 return SemaRef.ExprError(); 4014 } 4015 4016 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4017 if (SubExpr.isInvalid()) 4018 return SemaRef.ExprError(); 4019 4020 if (!getDerived().AlwaysRebuild() && 4021 ExplicitTy == E->getTypeAsWritten() && 4022 SubExpr.get() == E->getSubExpr()) 4023 return SemaRef.Owned(E->Retain()); 4024 4025 // FIXME: The end of the type's source range is wrong 4026 return getDerived().RebuildCXXFunctionalCastExpr( 4027 /*FIXME:*/SourceRange(E->getTypeBeginLoc()), 4028 ExplicitTy, 4029 /*FIXME:*/E->getSubExpr()->getLocStart(), 4030 move(SubExpr), 4031 E->getRParenLoc()); 4032} 4033 4034template<typename Derived> 4035Sema::OwningExprResult 4036TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) { 4037 if (E->isTypeOperand()) { 4038 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 4039 4040 QualType T = getDerived().TransformType(E->getTypeOperand()); 4041 if (T.isNull()) 4042 return SemaRef.ExprError(); 4043 4044 if (!getDerived().AlwaysRebuild() && 4045 T == E->getTypeOperand()) 4046 return SemaRef.Owned(E->Retain()); 4047 4048 return getDerived().RebuildCXXTypeidExpr(E->getLocStart(), 4049 /*FIXME:*/E->getLocStart(), 4050 T, 4051 E->getLocEnd()); 4052 } 4053 4054 // We don't know whether the expression is potentially evaluated until 4055 // after we perform semantic analysis, so the expression is potentially 4056 // potentially evaluated. 4057 EnterExpressionEvaluationContext Unevaluated(SemaRef, 4058 Action::PotentiallyPotentiallyEvaluated); 4059 4060 OwningExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); 4061 if (SubExpr.isInvalid()) 4062 return SemaRef.ExprError(); 4063 4064 if (!getDerived().AlwaysRebuild() && 4065 SubExpr.get() == E->getExprOperand()) 4066 return SemaRef.Owned(E->Retain()); 4067 4068 return getDerived().RebuildCXXTypeidExpr(E->getLocStart(), 4069 /*FIXME:*/E->getLocStart(), 4070 move(SubExpr), 4071 E->getLocEnd()); 4072} 4073 4074template<typename Derived> 4075Sema::OwningExprResult 4076TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 4077 return SemaRef.Owned(E->Retain()); 4078} 4079 4080template<typename Derived> 4081Sema::OwningExprResult 4082TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr( 4083 CXXNullPtrLiteralExpr *E) { 4084 return SemaRef.Owned(E->Retain()); 4085} 4086 4087template<typename Derived> 4088Sema::OwningExprResult 4089TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) { 4090 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 4091 4092 QualType T = getDerived().TransformType(E->getType()); 4093 if (T.isNull()) 4094 return SemaRef.ExprError(); 4095 4096 if (!getDerived().AlwaysRebuild() && 4097 T == E->getType()) 4098 return SemaRef.Owned(E->Retain()); 4099 4100 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T); 4101} 4102 4103template<typename Derived> 4104Sema::OwningExprResult 4105TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) { 4106 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4107 if (SubExpr.isInvalid()) 4108 return SemaRef.ExprError(); 4109 4110 if (!getDerived().AlwaysRebuild() && 4111 SubExpr.get() == E->getSubExpr()) 4112 return SemaRef.Owned(E->Retain()); 4113 4114 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), move(SubExpr)); 4115} 4116 4117template<typename Derived> 4118Sema::OwningExprResult 4119TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 4120 ParmVarDecl *Param 4121 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getParam())); 4122 if (!Param) 4123 return SemaRef.ExprError(); 4124 4125 if (getDerived().AlwaysRebuild() && 4126 Param == E->getParam()) 4127 return SemaRef.Owned(E->Retain()); 4128 4129 return getDerived().RebuildCXXDefaultArgExpr(Param); 4130} 4131 4132template<typename Derived> 4133Sema::OwningExprResult 4134TreeTransform<Derived>::TransformCXXZeroInitValueExpr(CXXZeroInitValueExpr *E) { 4135 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 4136 4137 QualType T = getDerived().TransformType(E->getType()); 4138 if (T.isNull()) 4139 return SemaRef.ExprError(); 4140 4141 if (!getDerived().AlwaysRebuild() && 4142 T == E->getType()) 4143 return SemaRef.Owned(E->Retain()); 4144 4145 return getDerived().RebuildCXXZeroInitValueExpr(E->getTypeBeginLoc(), 4146 /*FIXME:*/E->getTypeBeginLoc(), 4147 T, 4148 E->getRParenLoc()); 4149} 4150 4151template<typename Derived> 4152Sema::OwningExprResult 4153TreeTransform<Derived>::TransformCXXConditionDeclExpr(CXXConditionDeclExpr *E) { 4154 VarDecl *Var 4155 = cast_or_null<VarDecl>(getDerived().TransformDefinition(E->getVarDecl())); 4156 if (!Var) 4157 return SemaRef.ExprError(); 4158 4159 if (!getDerived().AlwaysRebuild() && 4160 Var == E->getVarDecl()) 4161 return SemaRef.Owned(E->Retain()); 4162 4163 return getDerived().RebuildCXXConditionDeclExpr(E->getStartLoc(), 4164 /*FIXME:*/E->getStartLoc(), 4165 Var); 4166} 4167 4168template<typename Derived> 4169Sema::OwningExprResult 4170TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { 4171 // Transform the type that we're allocating 4172 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 4173 QualType AllocType = getDerived().TransformType(E->getAllocatedType()); 4174 if (AllocType.isNull()) 4175 return SemaRef.ExprError(); 4176 4177 // Transform the size of the array we're allocating (if any). 4178 OwningExprResult ArraySize = getDerived().TransformExpr(E->getArraySize()); 4179 if (ArraySize.isInvalid()) 4180 return SemaRef.ExprError(); 4181 4182 // Transform the placement arguments (if any). 4183 bool ArgumentChanged = false; 4184 ASTOwningVector<&ActionBase::DeleteExpr> PlacementArgs(SemaRef); 4185 for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) { 4186 OwningExprResult Arg = getDerived().TransformExpr(E->getPlacementArg(I)); 4187 if (Arg.isInvalid()) 4188 return SemaRef.ExprError(); 4189 4190 ArgumentChanged = ArgumentChanged || Arg.get() != E->getPlacementArg(I); 4191 PlacementArgs.push_back(Arg.take()); 4192 } 4193 4194 // transform the constructor arguments (if any). 4195 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(SemaRef); 4196 for (unsigned I = 0, N = E->getNumConstructorArgs(); I != N; ++I) { 4197 OwningExprResult Arg = getDerived().TransformExpr(E->getConstructorArg(I)); 4198 if (Arg.isInvalid()) 4199 return SemaRef.ExprError(); 4200 4201 ArgumentChanged = ArgumentChanged || Arg.get() != E->getConstructorArg(I); 4202 ConstructorArgs.push_back(Arg.take()); 4203 } 4204 4205 if (!getDerived().AlwaysRebuild() && 4206 AllocType == E->getAllocatedType() && 4207 ArraySize.get() == E->getArraySize() && 4208 !ArgumentChanged) 4209 return SemaRef.Owned(E->Retain()); 4210 4211 return getDerived().RebuildCXXNewExpr(E->getLocStart(), 4212 E->isGlobalNew(), 4213 /*FIXME:*/E->getLocStart(), 4214 move_arg(PlacementArgs), 4215 /*FIXME:*/E->getLocStart(), 4216 E->isParenTypeId(), 4217 AllocType, 4218 /*FIXME:*/E->getLocStart(), 4219 /*FIXME:*/SourceRange(), 4220 move(ArraySize), 4221 /*FIXME:*/E->getLocStart(), 4222 move_arg(ConstructorArgs), 4223 E->getLocEnd()); 4224} 4225 4226template<typename Derived> 4227Sema::OwningExprResult 4228TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) { 4229 OwningExprResult Operand = getDerived().TransformExpr(E->getArgument()); 4230 if (Operand.isInvalid()) 4231 return SemaRef.ExprError(); 4232 4233 if (!getDerived().AlwaysRebuild() && 4234 Operand.get() == E->getArgument()) 4235 return SemaRef.Owned(E->Retain()); 4236 4237 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(), 4238 E->isGlobalDelete(), 4239 E->isArrayForm(), 4240 move(Operand)); 4241} 4242 4243template<typename Derived> 4244Sema::OwningExprResult 4245TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( 4246 CXXPseudoDestructorExpr *E) { 4247 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 4248 if (Base.isInvalid()) 4249 return SemaRef.ExprError(); 4250 4251 NestedNameSpecifier *Qualifier 4252 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 4253 E->getQualifierRange()); 4254 if (E->getQualifier() && !Qualifier) 4255 return SemaRef.ExprError(); 4256 4257 QualType DestroyedType; 4258 { 4259 TemporaryBase Rebase(*this, E->getDestroyedTypeLoc(), DeclarationName()); 4260 DestroyedType = getDerived().TransformType(E->getDestroyedType()); 4261 if (DestroyedType.isNull()) 4262 return SemaRef.ExprError(); 4263 } 4264 4265 if (!getDerived().AlwaysRebuild() && 4266 Base.get() == E->getBase() && 4267 Qualifier == E->getQualifier() && 4268 DestroyedType == E->getDestroyedType()) 4269 return SemaRef.Owned(E->Retain()); 4270 4271 return getDerived().RebuildCXXPseudoDestructorExpr(move(Base), 4272 E->getOperatorLoc(), 4273 E->isArrow(), 4274 E->getDestroyedTypeLoc(), 4275 DestroyedType, 4276 Qualifier, 4277 E->getQualifierRange()); 4278} 4279 4280template<typename Derived> 4281Sema::OwningExprResult 4282TreeTransform<Derived>::TransformUnresolvedFunctionNameExpr( 4283 UnresolvedFunctionNameExpr *E) { 4284 // There is no transformation we can apply to an unresolved function name. 4285 return SemaRef.Owned(E->Retain()); 4286} 4287 4288template<typename Derived> 4289Sema::OwningExprResult 4290TreeTransform<Derived>::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { 4291 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 4292 4293 QualType T = getDerived().TransformType(E->getQueriedType()); 4294 if (T.isNull()) 4295 return SemaRef.ExprError(); 4296 4297 if (!getDerived().AlwaysRebuild() && 4298 T == E->getQueriedType()) 4299 return SemaRef.Owned(E->Retain()); 4300 4301 // FIXME: Bad location information 4302 SourceLocation FakeLParenLoc 4303 = SemaRef.PP.getLocForEndOfToken(E->getLocStart()); 4304 4305 return getDerived().RebuildUnaryTypeTrait(E->getTrait(), 4306 E->getLocStart(), 4307 /*FIXME:*/FakeLParenLoc, 4308 T, 4309 E->getLocEnd()); 4310} 4311 4312template<typename Derived> 4313Sema::OwningExprResult 4314TreeTransform<Derived>::TransformUnresolvedDeclRefExpr( 4315 UnresolvedDeclRefExpr *E) { 4316 NestedNameSpecifier *NNS 4317 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 4318 E->getQualifierRange()); 4319 if (!NNS) 4320 return SemaRef.ExprError(); 4321 4322 DeclarationName Name 4323 = getDerived().TransformDeclarationName(E->getDeclName(), E->getLocation()); 4324 if (!Name) 4325 return SemaRef.ExprError(); 4326 4327 if (!getDerived().AlwaysRebuild() && 4328 NNS == E->getQualifier() && 4329 Name == E->getDeclName()) 4330 return SemaRef.Owned(E->Retain()); 4331 4332 return getDerived().RebuildUnresolvedDeclRefExpr(NNS, 4333 E->getQualifierRange(), 4334 Name, 4335 E->getLocation(), 4336 /*FIXME:*/false); 4337} 4338 4339template<typename Derived> 4340Sema::OwningExprResult 4341TreeTransform<Derived>::TransformTemplateIdRefExpr(TemplateIdRefExpr *E) { 4342 TemplateName Template 4343 = getDerived().TransformTemplateName(E->getTemplateName()); 4344 if (Template.isNull()) 4345 return SemaRef.ExprError(); 4346 4347 NestedNameSpecifier *Qualifier = 0; 4348 if (E->getQualifier()) { 4349 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 4350 E->getQualifierRange()); 4351 if (!Qualifier) 4352 return SemaRef.ExprError(); 4353 } 4354 4355 llvm::SmallVector<TemplateArgument, 4> TransArgs; 4356 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 4357 TemplateArgument TransArg 4358 = getDerived().TransformTemplateArgument(E->getTemplateArgs()[I]); 4359 if (TransArg.isNull()) 4360 return SemaRef.ExprError(); 4361 4362 TransArgs.push_back(TransArg); 4363 } 4364 4365 // FIXME: Would like to avoid rebuilding if nothing changed, but we can't 4366 // compare template arguments (yet). 4367 4368 // FIXME: It's possible that we'll find out now that the template name 4369 // actually refers to a type, in which case the caller is actually dealing 4370 // with a functional cast. Give a reasonable error message! 4371 return getDerived().RebuildTemplateIdExpr(Qualifier, E->getQualifierRange(), 4372 Template, E->getTemplateNameLoc(), 4373 E->getLAngleLoc(), 4374 TransArgs.data(), 4375 TransArgs.size(), 4376 E->getRAngleLoc()); 4377} 4378 4379template<typename Derived> 4380Sema::OwningExprResult 4381TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) { 4382 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 4383 4384 QualType T = getDerived().TransformType(E->getType()); 4385 if (T.isNull()) 4386 return SemaRef.ExprError(); 4387 4388 CXXConstructorDecl *Constructor 4389 = cast_or_null<CXXConstructorDecl>( 4390 getDerived().TransformDecl(E->getConstructor())); 4391 if (!Constructor) 4392 return SemaRef.ExprError(); 4393 4394 bool ArgumentChanged = false; 4395 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 4396 for (CXXConstructExpr::arg_iterator Arg = E->arg_begin(), 4397 ArgEnd = E->arg_end(); 4398 Arg != ArgEnd; ++Arg) { 4399 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 4400 if (TransArg.isInvalid()) 4401 return SemaRef.ExprError(); 4402 4403 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 4404 Args.push_back(TransArg.takeAs<Expr>()); 4405 } 4406 4407 if (!getDerived().AlwaysRebuild() && 4408 T == E->getType() && 4409 Constructor == E->getConstructor() && 4410 !ArgumentChanged) 4411 return SemaRef.Owned(E->Retain()); 4412 4413 return getDerived().RebuildCXXConstructExpr(T, Constructor, E->isElidable(), 4414 move_arg(Args)); 4415} 4416 4417/// \brief Transform a C++ temporary-binding expression. 4418/// 4419/// The transformation of a temporary-binding expression always attempts to 4420/// bind a new temporary variable to its subexpression, even if the 4421/// subexpression itself did not change, because the temporary variable itself 4422/// must be unique. 4423template<typename Derived> 4424Sema::OwningExprResult 4425TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 4426 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4427 if (SubExpr.isInvalid()) 4428 return SemaRef.ExprError(); 4429 4430 return SemaRef.MaybeBindToTemporary(SubExpr.takeAs<Expr>()); 4431} 4432 4433/// \brief Transform a C++ expression that contains temporaries that should 4434/// be destroyed after the expression is evaluated. 4435/// 4436/// The transformation of a full expression always attempts to build a new 4437/// CXXExprWithTemporaries expression, even if the 4438/// subexpression itself did not change, because it will need to capture the 4439/// the new temporary variables introduced in the subexpression. 4440template<typename Derived> 4441Sema::OwningExprResult 4442TreeTransform<Derived>::TransformCXXExprWithTemporaries( 4443 CXXExprWithTemporaries *E) { 4444 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4445 if (SubExpr.isInvalid()) 4446 return SemaRef.ExprError(); 4447 4448 return SemaRef.Owned( 4449 SemaRef.MaybeCreateCXXExprWithTemporaries(SubExpr.takeAs<Expr>(), 4450 E->shouldDestroyTemporaries())); 4451} 4452 4453template<typename Derived> 4454Sema::OwningExprResult 4455TreeTransform<Derived>::TransformCXXTemporaryObjectExpr( 4456 CXXTemporaryObjectExpr *E) { 4457 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 4458 QualType T = getDerived().TransformType(E->getType()); 4459 if (T.isNull()) 4460 return SemaRef.ExprError(); 4461 4462 CXXConstructorDecl *Constructor 4463 = cast_or_null<CXXConstructorDecl>( 4464 getDerived().TransformDecl(E->getConstructor())); 4465 if (!Constructor) 4466 return SemaRef.ExprError(); 4467 4468 bool ArgumentChanged = false; 4469 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 4470 Args.reserve(E->getNumArgs()); 4471 for (CXXTemporaryObjectExpr::arg_iterator Arg = E->arg_begin(), 4472 ArgEnd = E->arg_end(); 4473 Arg != ArgEnd; ++Arg) { 4474 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 4475 if (TransArg.isInvalid()) 4476 return SemaRef.ExprError(); 4477 4478 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 4479 Args.push_back((Expr *)TransArg.release()); 4480 } 4481 4482 if (!getDerived().AlwaysRebuild() && 4483 T == E->getType() && 4484 Constructor == E->getConstructor() && 4485 !ArgumentChanged) 4486 return SemaRef.Owned(E->Retain()); 4487 4488 // FIXME: Bogus location information 4489 SourceLocation CommaLoc; 4490 if (Args.size() > 1) { 4491 Expr *First = (Expr *)Args[0]; 4492 CommaLoc 4493 = SemaRef.PP.getLocForEndOfToken(First->getSourceRange().getEnd()); 4494 } 4495 return getDerived().RebuildCXXTemporaryObjectExpr(E->getTypeBeginLoc(), 4496 T, 4497 /*FIXME:*/E->getTypeBeginLoc(), 4498 move_arg(Args), 4499 &CommaLoc, 4500 E->getLocEnd()); 4501} 4502 4503template<typename Derived> 4504Sema::OwningExprResult 4505TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( 4506 CXXUnresolvedConstructExpr *E) { 4507 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 4508 QualType T = getDerived().TransformType(E->getTypeAsWritten()); 4509 if (T.isNull()) 4510 return SemaRef.ExprError(); 4511 4512 bool ArgumentChanged = false; 4513 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 4514 llvm::SmallVector<SourceLocation, 8> FakeCommaLocs; 4515 for (CXXUnresolvedConstructExpr::arg_iterator Arg = E->arg_begin(), 4516 ArgEnd = E->arg_end(); 4517 Arg != ArgEnd; ++Arg) { 4518 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 4519 if (TransArg.isInvalid()) 4520 return SemaRef.ExprError(); 4521 4522 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 4523 FakeCommaLocs.push_back( 4524 SemaRef.PP.getLocForEndOfToken((*Arg)->getLocEnd())); 4525 Args.push_back(TransArg.takeAs<Expr>()); 4526 } 4527 4528 if (!getDerived().AlwaysRebuild() && 4529 T == E->getTypeAsWritten() && 4530 !ArgumentChanged) 4531 return SemaRef.Owned(E->Retain()); 4532 4533 // FIXME: we're faking the locations of the commas 4534 return getDerived().RebuildCXXUnresolvedConstructExpr(E->getTypeBeginLoc(), 4535 T, 4536 E->getLParenLoc(), 4537 move_arg(Args), 4538 FakeCommaLocs.data(), 4539 E->getRParenLoc()); 4540} 4541 4542template<typename Derived> 4543Sema::OwningExprResult 4544TreeTransform<Derived>::TransformCXXUnresolvedMemberExpr( 4545 CXXUnresolvedMemberExpr *E) { 4546 // Transform the base of the expression. 4547 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 4548 if (Base.isInvalid()) 4549 return SemaRef.ExprError(); 4550 4551 // Start the member reference and compute the object's type. 4552 Sema::TypeTy *ObjectType = 0; 4553 Base = SemaRef.ActOnStartCXXMemberReference(0, move(Base), 4554 E->getOperatorLoc(), 4555 E->isArrow()? tok::arrow : tok::period, 4556 ObjectType); 4557 if (Base.isInvalid()) 4558 return SemaRef.ExprError(); 4559 4560 // Transform the first part of the nested-name-specifier that qualifies 4561 // the member name. 4562 NamedDecl *FirstQualifierInScope 4563 = getDerived().TransformFirstQualifierInScope( 4564 E->getFirstQualifierFoundInScope(), 4565 E->getQualifierRange().getBegin()); 4566 4567 NestedNameSpecifier *Qualifier = 0; 4568 if (E->getQualifier()) { 4569 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 4570 E->getQualifierRange(), 4571 QualType::getFromOpaquePtr(ObjectType), 4572 FirstQualifierInScope); 4573 if (!Qualifier) 4574 return SemaRef.ExprError(); 4575 } 4576 4577 DeclarationName Name 4578 = getDerived().TransformDeclarationName(E->getMember(), E->getMemberLoc(), 4579 QualType::getFromOpaquePtr(ObjectType)); 4580 if (!Name) 4581 return SemaRef.ExprError(); 4582 4583 if (!E->hasExplicitTemplateArgumentList()) { 4584 // This is a reference to a member without an explicitly-specified 4585 // template argument list. Optimize for this common case. 4586 if (!getDerived().AlwaysRebuild() && 4587 Base.get() == E->getBase() && 4588 Qualifier == E->getQualifier() && 4589 Name == E->getMember() && 4590 FirstQualifierInScope == E->getFirstQualifierFoundInScope()) 4591 return SemaRef.Owned(E->Retain()); 4592 4593 return getDerived().RebuildCXXUnresolvedMemberExpr(move(Base), 4594 E->isArrow(), 4595 E->getOperatorLoc(), 4596 Qualifier, 4597 E->getQualifierRange(), 4598 Name, 4599 E->getMemberLoc(), 4600 FirstQualifierInScope); 4601 } 4602 4603 // FIXME: This is an ugly hack, which forces the same template name to 4604 // be looked up multiple times. Yuck! 4605 // FIXME: This also won't work for, e.g., x->template operator+<int> 4606 TemplateName OrigTemplateName 4607 = SemaRef.Context.getDependentTemplateName(0, Name.getAsIdentifierInfo()); 4608 4609 TemplateName Template 4610 = getDerived().TransformTemplateName(OrigTemplateName, 4611 QualType::getFromOpaquePtr(ObjectType)); 4612 if (Template.isNull()) 4613 return SemaRef.ExprError(); 4614 4615 llvm::SmallVector<TemplateArgument, 4> TransArgs; 4616 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 4617 TemplateArgument TransArg 4618 = getDerived().TransformTemplateArgument(E->getTemplateArgs()[I]); 4619 if (TransArg.isNull()) 4620 return SemaRef.ExprError(); 4621 4622 TransArgs.push_back(TransArg); 4623 } 4624 4625 return getDerived().RebuildCXXUnresolvedMemberExpr(move(Base), 4626 E->isArrow(), 4627 E->getOperatorLoc(), 4628 Qualifier, 4629 E->getQualifierRange(), 4630 Template, 4631 E->getMemberLoc(), 4632 FirstQualifierInScope, 4633 E->getLAngleLoc(), 4634 TransArgs.data(), 4635 TransArgs.size(), 4636 E->getRAngleLoc()); 4637} 4638 4639template<typename Derived> 4640Sema::OwningExprResult 4641TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) { 4642 return SemaRef.Owned(E->Retain()); 4643} 4644 4645template<typename Derived> 4646Sema::OwningExprResult 4647TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) { 4648 // FIXME: poor source location 4649 TemporaryBase Rebase(*this, E->getAtLoc(), DeclarationName()); 4650 QualType EncodedType = getDerived().TransformType(E->getEncodedType()); 4651 if (EncodedType.isNull()) 4652 return SemaRef.ExprError(); 4653 4654 if (!getDerived().AlwaysRebuild() && 4655 EncodedType == E->getEncodedType()) 4656 return SemaRef.Owned(E->Retain()); 4657 4658 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(), 4659 EncodedType, 4660 E->getRParenLoc()); 4661} 4662 4663template<typename Derived> 4664Sema::OwningExprResult 4665TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) { 4666 // FIXME: Implement this! 4667 assert(false && "Cannot transform Objective-C expressions yet"); 4668 return SemaRef.Owned(E->Retain()); 4669} 4670 4671template<typename Derived> 4672Sema::OwningExprResult 4673TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) { 4674 return SemaRef.Owned(E->Retain()); 4675} 4676 4677template<typename Derived> 4678Sema::OwningExprResult 4679TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) { 4680 ObjCProtocolDecl *Protocol 4681 = cast_or_null<ObjCProtocolDecl>( 4682 getDerived().TransformDecl(E->getProtocol())); 4683 if (!Protocol) 4684 return SemaRef.ExprError(); 4685 4686 if (!getDerived().AlwaysRebuild() && 4687 Protocol == E->getProtocol()) 4688 return SemaRef.Owned(E->Retain()); 4689 4690 return getDerived().RebuildObjCProtocolExpr(Protocol, 4691 E->getAtLoc(), 4692 /*FIXME:*/E->getAtLoc(), 4693 /*FIXME:*/E->getAtLoc(), 4694 E->getRParenLoc()); 4695 4696} 4697 4698template<typename Derived> 4699Sema::OwningExprResult 4700TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) { 4701 // FIXME: Implement this! 4702 assert(false && "Cannot transform Objective-C expressions yet"); 4703 return SemaRef.Owned(E->Retain()); 4704} 4705 4706template<typename Derived> 4707Sema::OwningExprResult 4708TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 4709 // FIXME: Implement this! 4710 assert(false && "Cannot transform Objective-C expressions yet"); 4711 return SemaRef.Owned(E->Retain()); 4712} 4713 4714template<typename Derived> 4715Sema::OwningExprResult 4716TreeTransform<Derived>::TransformObjCImplicitSetterGetterRefExpr( 4717 ObjCImplicitSetterGetterRefExpr *E) { 4718 // FIXME: Implement this! 4719 assert(false && "Cannot transform Objective-C expressions yet"); 4720 return SemaRef.Owned(E->Retain()); 4721} 4722 4723template<typename Derived> 4724Sema::OwningExprResult 4725TreeTransform<Derived>::TransformObjCSuperExpr(ObjCSuperExpr *E) { 4726 // FIXME: Implement this! 4727 assert(false && "Cannot transform Objective-C expressions yet"); 4728 return SemaRef.Owned(E->Retain()); 4729} 4730 4731template<typename Derived> 4732Sema::OwningExprResult 4733TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) { 4734 // FIXME: Implement this! 4735 assert(false && "Cannot transform Objective-C expressions yet"); 4736 return SemaRef.Owned(E->Retain()); 4737} 4738 4739template<typename Derived> 4740Sema::OwningExprResult 4741TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) { 4742 bool ArgumentChanged = false; 4743 ASTOwningVector<&ActionBase::DeleteExpr> SubExprs(SemaRef); 4744 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) { 4745 OwningExprResult SubExpr = getDerived().TransformExpr(E->getExpr(I)); 4746 if (SubExpr.isInvalid()) 4747 return SemaRef.ExprError(); 4748 4749 ArgumentChanged = ArgumentChanged || SubExpr.get() != E->getExpr(I); 4750 SubExprs.push_back(SubExpr.takeAs<Expr>()); 4751 } 4752 4753 if (!getDerived().AlwaysRebuild() && 4754 !ArgumentChanged) 4755 return SemaRef.Owned(E->Retain()); 4756 4757 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(), 4758 move_arg(SubExprs), 4759 E->getRParenLoc()); 4760} 4761 4762template<typename Derived> 4763Sema::OwningExprResult 4764TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { 4765 // FIXME: Implement this! 4766 assert(false && "Cannot transform block expressions yet"); 4767 return SemaRef.Owned(E->Retain()); 4768} 4769 4770template<typename Derived> 4771Sema::OwningExprResult 4772TreeTransform<Derived>::TransformBlockDeclRefExpr(BlockDeclRefExpr *E) { 4773 // FIXME: Implement this! 4774 assert(false && "Cannot transform block-related expressions yet"); 4775 return SemaRef.Owned(E->Retain()); 4776} 4777 4778//===----------------------------------------------------------------------===// 4779// Type reconstruction 4780//===----------------------------------------------------------------------===// 4781 4782template<typename Derived> 4783QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType) { 4784 return SemaRef.BuildPointerType(PointeeType, Qualifiers(), 4785 getDerived().getBaseLocation(), 4786 getDerived().getBaseEntity()); 4787} 4788 4789template<typename Derived> 4790QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType) { 4791 return SemaRef.BuildBlockPointerType(PointeeType, Qualifiers(), 4792 getDerived().getBaseLocation(), 4793 getDerived().getBaseEntity()); 4794} 4795 4796template<typename Derived> 4797QualType 4798TreeTransform<Derived>::RebuildLValueReferenceType(QualType ReferentType) { 4799 return SemaRef.BuildReferenceType(ReferentType, true, Qualifiers(), 4800 getDerived().getBaseLocation(), 4801 getDerived().getBaseEntity()); 4802} 4803 4804template<typename Derived> 4805QualType 4806TreeTransform<Derived>::RebuildRValueReferenceType(QualType ReferentType) { 4807 return SemaRef.BuildReferenceType(ReferentType, false, Qualifiers(), 4808 getDerived().getBaseLocation(), 4809 getDerived().getBaseEntity()); 4810} 4811 4812template<typename Derived> 4813QualType TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType, 4814 QualType ClassType) { 4815 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Qualifiers(), 4816 getDerived().getBaseLocation(), 4817 getDerived().getBaseEntity()); 4818} 4819 4820template<typename Derived> 4821QualType 4822TreeTransform<Derived>::RebuildObjCObjectPointerType(QualType PointeeType) { 4823 return SemaRef.BuildPointerType(PointeeType, Qualifiers(), 4824 getDerived().getBaseLocation(), 4825 getDerived().getBaseEntity()); 4826} 4827 4828template<typename Derived> 4829QualType 4830TreeTransform<Derived>::RebuildArrayType(QualType ElementType, 4831 ArrayType::ArraySizeModifier SizeMod, 4832 const llvm::APInt *Size, 4833 Expr *SizeExpr, 4834 unsigned IndexTypeQuals, 4835 SourceRange BracketsRange) { 4836 if (SizeExpr || !Size) 4837 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr, 4838 IndexTypeQuals, BracketsRange, 4839 getDerived().getBaseEntity()); 4840 4841 QualType Types[] = { 4842 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy, 4843 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, 4844 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty 4845 }; 4846 const unsigned NumTypes = sizeof(Types) / sizeof(QualType); 4847 QualType SizeType; 4848 for (unsigned I = 0; I != NumTypes; ++I) 4849 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) { 4850 SizeType = Types[I]; 4851 break; 4852 } 4853 4854 if (SizeType.isNull()) 4855 SizeType = SemaRef.Context.getFixedWidthIntType(Size->getBitWidth(), false); 4856 4857 IntegerLiteral ArraySize(*Size, SizeType, /*FIXME*/BracketsRange.getBegin()); 4858 return SemaRef.BuildArrayType(ElementType, SizeMod, &ArraySize, 4859 IndexTypeQuals, BracketsRange, 4860 getDerived().getBaseEntity()); 4861} 4862 4863template<typename Derived> 4864QualType 4865TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType, 4866 ArrayType::ArraySizeModifier SizeMod, 4867 const llvm::APInt &Size, 4868 unsigned IndexTypeQuals) { 4869 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0, 4870 IndexTypeQuals, SourceRange()); 4871} 4872 4873template<typename Derived> 4874QualType 4875TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType, 4876 ArrayType::ArraySizeModifier SizeMod, 4877 unsigned IndexTypeQuals) { 4878 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 0, 4879 IndexTypeQuals, SourceRange()); 4880} 4881 4882template<typename Derived> 4883QualType 4884TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType, 4885 ArrayType::ArraySizeModifier SizeMod, 4886 ExprArg SizeExpr, 4887 unsigned IndexTypeQuals, 4888 SourceRange BracketsRange) { 4889 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 4890 SizeExpr.takeAs<Expr>(), 4891 IndexTypeQuals, BracketsRange); 4892} 4893 4894template<typename Derived> 4895QualType 4896TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType, 4897 ArrayType::ArraySizeModifier SizeMod, 4898 ExprArg SizeExpr, 4899 unsigned IndexTypeQuals, 4900 SourceRange BracketsRange) { 4901 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 4902 SizeExpr.takeAs<Expr>(), 4903 IndexTypeQuals, BracketsRange); 4904} 4905 4906template<typename Derived> 4907QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType, 4908 unsigned NumElements) { 4909 // FIXME: semantic checking! 4910 return SemaRef.Context.getVectorType(ElementType, NumElements); 4911} 4912 4913template<typename Derived> 4914QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType, 4915 unsigned NumElements, 4916 SourceLocation AttributeLoc) { 4917 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy), 4918 NumElements, true); 4919 IntegerLiteral *VectorSize 4920 = new (SemaRef.Context) IntegerLiteral(numElements, SemaRef.Context.IntTy, 4921 AttributeLoc); 4922 return SemaRef.BuildExtVectorType(ElementType, SemaRef.Owned(VectorSize), 4923 AttributeLoc); 4924} 4925 4926template<typename Derived> 4927QualType 4928TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType, 4929 ExprArg SizeExpr, 4930 SourceLocation AttributeLoc) { 4931 return SemaRef.BuildExtVectorType(ElementType, move(SizeExpr), AttributeLoc); 4932} 4933 4934template<typename Derived> 4935QualType TreeTransform<Derived>::RebuildFunctionProtoType(QualType T, 4936 QualType *ParamTypes, 4937 unsigned NumParamTypes, 4938 bool Variadic, 4939 unsigned Quals) { 4940 return SemaRef.BuildFunctionType(T, ParamTypes, NumParamTypes, Variadic, 4941 Quals, 4942 getDerived().getBaseLocation(), 4943 getDerived().getBaseEntity()); 4944} 4945 4946template<typename Derived> 4947QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) { 4948 return SemaRef.Context.getFunctionNoProtoType(T); 4949} 4950 4951template<typename Derived> 4952QualType TreeTransform<Derived>::RebuildTypeOfExprType(ExprArg E) { 4953 return SemaRef.BuildTypeofExprType(E.takeAs<Expr>()); 4954} 4955 4956template<typename Derived> 4957QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) { 4958 return SemaRef.Context.getTypeOfType(Underlying); 4959} 4960 4961template<typename Derived> 4962QualType TreeTransform<Derived>::RebuildDecltypeType(ExprArg E) { 4963 return SemaRef.BuildDecltypeType(E.takeAs<Expr>()); 4964} 4965 4966template<typename Derived> 4967QualType TreeTransform<Derived>::RebuildTemplateSpecializationType( 4968 TemplateName Template, 4969 const TemplateArgument *Args, 4970 unsigned NumArgs) { 4971 // FIXME: Missing source locations for the template name, <, >. 4972 return SemaRef.CheckTemplateIdType(Template, getDerived().getBaseLocation(), 4973 SourceLocation(), Args, NumArgs, 4974 SourceLocation()); 4975} 4976 4977template<typename Derived> 4978NestedNameSpecifier * 4979TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 4980 SourceRange Range, 4981 IdentifierInfo &II, 4982 QualType ObjectType, 4983 NamedDecl *FirstQualifierInScope) { 4984 CXXScopeSpec SS; 4985 // FIXME: The source location information is all wrong. 4986 SS.setRange(Range); 4987 SS.setScopeRep(Prefix); 4988 return static_cast<NestedNameSpecifier *>( 4989 SemaRef.BuildCXXNestedNameSpecifier(0, SS, Range.getEnd(), 4990 Range.getEnd(), II, 4991 ObjectType, 4992 FirstQualifierInScope, 4993 false)); 4994} 4995 4996template<typename Derived> 4997NestedNameSpecifier * 4998TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 4999 SourceRange Range, 5000 NamespaceDecl *NS) { 5001 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, NS); 5002} 5003 5004template<typename Derived> 5005NestedNameSpecifier * 5006TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 5007 SourceRange Range, 5008 bool TemplateKW, 5009 QualType T) { 5010 if (T->isDependentType() || T->isRecordType() || 5011 (SemaRef.getLangOptions().CPlusPlus0x && T->isEnumeralType())) { 5012 assert(!T.hasQualifiers() && "Can't get cv-qualifiers here"); 5013 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, TemplateKW, 5014 T.getTypePtr()); 5015 } 5016 5017 SemaRef.Diag(Range.getBegin(), diag::err_nested_name_spec_non_tag) << T; 5018 return 0; 5019} 5020 5021template<typename Derived> 5022TemplateName 5023TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5024 bool TemplateKW, 5025 TemplateDecl *Template) { 5026 return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW, 5027 Template); 5028} 5029 5030template<typename Derived> 5031TemplateName 5032TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5033 bool TemplateKW, 5034 OverloadedFunctionDecl *Ovl) { 5035 return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW, Ovl); 5036} 5037 5038template<typename Derived> 5039TemplateName 5040TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5041 const IdentifierInfo &II, 5042 QualType ObjectType) { 5043 CXXScopeSpec SS; 5044 SS.setRange(SourceRange(getDerived().getBaseLocation())); 5045 SS.setScopeRep(Qualifier); 5046 return getSema().ActOnDependentTemplateName( 5047 /*FIXME:*/getDerived().getBaseLocation(), 5048 II, 5049 /*FIXME:*/getDerived().getBaseLocation(), 5050 SS, 5051 ObjectType.getAsOpaquePtr()) 5052 .template getAsVal<TemplateName>(); 5053} 5054 5055template<typename Derived> 5056Sema::OwningExprResult 5057TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, 5058 SourceLocation OpLoc, 5059 ExprArg Callee, 5060 ExprArg First, 5061 ExprArg Second) { 5062 Expr *FirstExpr = (Expr *)First.get(); 5063 Expr *SecondExpr = (Expr *)Second.get(); 5064 bool isPostIncDec = SecondExpr && (Op == OO_PlusPlus || Op == OO_MinusMinus); 5065 5066 // Determine whether this should be a builtin operation. 5067 if (SecondExpr == 0 || isPostIncDec) { 5068 if (!FirstExpr->getType()->isOverloadableType()) { 5069 // The argument is not of overloadable type, so try to create a 5070 // built-in unary operation. 5071 UnaryOperator::Opcode Opc 5072 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 5073 5074 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, move(First)); 5075 } 5076 } else { 5077 if (!FirstExpr->getType()->isOverloadableType() && 5078 !SecondExpr->getType()->isOverloadableType()) { 5079 // Neither of the arguments is an overloadable type, so try to 5080 // create a built-in binary operation. 5081 BinaryOperator::Opcode Opc = BinaryOperator::getOverloadedOpcode(Op); 5082 OwningExprResult Result 5083 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, FirstExpr, SecondExpr); 5084 if (Result.isInvalid()) 5085 return SemaRef.ExprError(); 5086 5087 First.release(); 5088 Second.release(); 5089 return move(Result); 5090 } 5091 } 5092 5093 // Compute the transformed set of functions (and function templates) to be 5094 // used during overload resolution. 5095 Sema::FunctionSet Functions; 5096 5097 DeclRefExpr *DRE 5098 = cast<DeclRefExpr>(((Expr *)Callee.get())->IgnoreParenCasts()); 5099 5100 // FIXME: Do we have to check 5101 // IsAcceptableNonMemberOperatorCandidate for each of these? 5102 for (OverloadIterator F(DRE->getDecl()), FEnd; F != FEnd; ++F) 5103 Functions.insert(*F); 5104 5105 // Add any functions found via argument-dependent lookup. 5106 Expr *Args[2] = { FirstExpr, SecondExpr }; 5107 unsigned NumArgs = 1 + (SecondExpr != 0); 5108 DeclarationName OpName 5109 = SemaRef.Context.DeclarationNames.getCXXOperatorName(Op); 5110 SemaRef.ArgumentDependentLookup(OpName, Args, NumArgs, Functions); 5111 5112 // Create the overloaded operator invocation for unary operators. 5113 if (NumArgs == 1 || isPostIncDec) { 5114 UnaryOperator::Opcode Opc 5115 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 5116 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, move(First)); 5117 } 5118 5119 // Create the overloaded operator invocation for binary operators. 5120 BinaryOperator::Opcode Opc = 5121 BinaryOperator::getOverloadedOpcode(Op); 5122 OwningExprResult Result 5123 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]); 5124 if (Result.isInvalid()) 5125 return SemaRef.ExprError(); 5126 5127 First.release(); 5128 Second.release(); 5129 return move(Result); 5130} 5131 5132} // end namespace clang 5133 5134#endif // LLVM_CLANG_SEMA_TREETRANSFORM_H 5135