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