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