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