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