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