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