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