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