TreeTransform.h revision 0da76df9218d7c27b471b0a4d83a5b29fe24e5b4
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 const TemplateArgumentListInfo &Args); 507 508 /// \brief Build a new qualified name type. 509 /// 510 /// By default, builds a new QualifiedNameType type from the 511 /// nested-name-specifier and the named type. Subclasses may override 512 /// this routine to provide different behavior. 513 QualType RebuildQualifiedNameType(NestedNameSpecifier *NNS, QualType Named) { 514 return SemaRef.Context.getQualifiedNameType(NNS, Named); 515 } 516 517 /// \brief Build a new typename type that refers to a template-id. 518 /// 519 /// By default, builds a new TypenameType type from the nested-name-specifier 520 /// and the given type. Subclasses may override this routine to provide 521 /// different behavior. 522 QualType RebuildTypenameType(NestedNameSpecifier *NNS, QualType T) { 523 if (NNS->isDependent()) 524 return SemaRef.Context.getTypenameType(NNS, 525 cast<TemplateSpecializationType>(T)); 526 527 return SemaRef.Context.getQualifiedNameType(NNS, T); 528 } 529 530 /// \brief Build a new typename type that refers to an identifier. 531 /// 532 /// By default, performs semantic analysis when building the typename type 533 /// (or qualified name type). Subclasses may override this routine to provide 534 /// different behavior. 535 QualType RebuildTypenameType(NestedNameSpecifier *NNS, 536 const IdentifierInfo *Id, 537 SourceRange SR) { 538 return SemaRef.CheckTypenameType(NNS, *Id, SR); 539 } 540 541 /// \brief Build a new nested-name-specifier given the prefix and an 542 /// identifier that names the next step in the nested-name-specifier. 543 /// 544 /// By default, performs semantic analysis when building the new 545 /// nested-name-specifier. Subclasses may override this routine to provide 546 /// different behavior. 547 NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 548 SourceRange Range, 549 IdentifierInfo &II, 550 QualType ObjectType, 551 NamedDecl *FirstQualifierInScope); 552 553 /// \brief Build a new nested-name-specifier given the prefix and the 554 /// namespace named in the next step in the nested-name-specifier. 555 /// 556 /// By default, performs semantic analysis when building the new 557 /// nested-name-specifier. Subclasses may override this routine to provide 558 /// different behavior. 559 NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 560 SourceRange Range, 561 NamespaceDecl *NS); 562 563 /// \brief Build a new nested-name-specifier given the prefix and the 564 /// type named in the next step in the nested-name-specifier. 565 /// 566 /// By default, performs semantic analysis when building the new 567 /// nested-name-specifier. Subclasses may override this routine to provide 568 /// different behavior. 569 NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 570 SourceRange Range, 571 bool TemplateKW, 572 QualType T); 573 574 /// \brief Build a new template name given a nested name specifier, a flag 575 /// indicating whether the "template" keyword was provided, and the template 576 /// that the template name refers to. 577 /// 578 /// By default, builds the new template name directly. Subclasses may override 579 /// this routine to provide different behavior. 580 TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier, 581 bool TemplateKW, 582 TemplateDecl *Template); 583 584 /// \brief Build a new template name given a nested name specifier, a flag 585 /// indicating whether the "template" keyword was provided, and a set of 586 /// overloaded function templates. 587 /// 588 /// By default, builds the new template name directly. Subclasses may override 589 /// this routine to provide different behavior. 590 TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier, 591 bool TemplateKW, 592 OverloadedFunctionDecl *Ovl); 593 594 /// \brief Build a new template name given a nested name specifier and the 595 /// name that is referred to as a template. 596 /// 597 /// By default, performs semantic analysis to determine whether the name can 598 /// be resolved to a specific template, then builds the appropriate kind of 599 /// template name. Subclasses may override this routine to provide different 600 /// behavior. 601 TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier, 602 const IdentifierInfo &II, 603 QualType ObjectType); 604 605 /// \brief Build a new template name given a nested name specifier and the 606 /// overloaded operator name that is referred to as a template. 607 /// 608 /// By default, performs semantic analysis to determine whether the name can 609 /// be resolved to a specific template, then builds the appropriate kind of 610 /// template name. Subclasses may override this routine to provide different 611 /// behavior. 612 TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier, 613 OverloadedOperatorKind Operator, 614 QualType ObjectType); 615 616 /// \brief Build a new compound statement. 617 /// 618 /// By default, performs semantic analysis to build the new statement. 619 /// Subclasses may override this routine to provide different behavior. 620 OwningStmtResult RebuildCompoundStmt(SourceLocation LBraceLoc, 621 MultiStmtArg Statements, 622 SourceLocation RBraceLoc, 623 bool IsStmtExpr) { 624 return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, move(Statements), 625 IsStmtExpr); 626 } 627 628 /// \brief Build a new case statement. 629 /// 630 /// By default, performs semantic analysis to build the new statement. 631 /// Subclasses may override this routine to provide different behavior. 632 OwningStmtResult RebuildCaseStmt(SourceLocation CaseLoc, 633 ExprArg LHS, 634 SourceLocation EllipsisLoc, 635 ExprArg RHS, 636 SourceLocation ColonLoc) { 637 return getSema().ActOnCaseStmt(CaseLoc, move(LHS), EllipsisLoc, move(RHS), 638 ColonLoc); 639 } 640 641 /// \brief Attach the body to a new case statement. 642 /// 643 /// By default, performs semantic analysis to build the new statement. 644 /// Subclasses may override this routine to provide different behavior. 645 OwningStmtResult RebuildCaseStmtBody(StmtArg S, StmtArg Body) { 646 getSema().ActOnCaseStmtBody(S.get(), move(Body)); 647 return move(S); 648 } 649 650 /// \brief Build a new default statement. 651 /// 652 /// By default, performs semantic analysis to build the new statement. 653 /// Subclasses may override this routine to provide different behavior. 654 OwningStmtResult RebuildDefaultStmt(SourceLocation DefaultLoc, 655 SourceLocation ColonLoc, 656 StmtArg SubStmt) { 657 return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, move(SubStmt), 658 /*CurScope=*/0); 659 } 660 661 /// \brief Build a new label statement. 662 /// 663 /// By default, performs semantic analysis to build the new statement. 664 /// Subclasses may override this routine to provide different behavior. 665 OwningStmtResult RebuildLabelStmt(SourceLocation IdentLoc, 666 IdentifierInfo *Id, 667 SourceLocation ColonLoc, 668 StmtArg SubStmt) { 669 return SemaRef.ActOnLabelStmt(IdentLoc, Id, ColonLoc, move(SubStmt)); 670 } 671 672 /// \brief Build a new "if" statement. 673 /// 674 /// By default, performs semantic analysis to build the new statement. 675 /// Subclasses may override this routine to provide different behavior. 676 OwningStmtResult RebuildIfStmt(SourceLocation IfLoc, Sema::FullExprArg Cond, 677 StmtArg Then, SourceLocation ElseLoc, 678 StmtArg Else) { 679 return getSema().ActOnIfStmt(IfLoc, Cond, move(Then), ElseLoc, move(Else)); 680 } 681 682 /// \brief Start building a new switch statement. 683 /// 684 /// By default, performs semantic analysis to build the new statement. 685 /// Subclasses may override this routine to provide different behavior. 686 OwningStmtResult RebuildSwitchStmtStart(ExprArg Cond) { 687 return getSema().ActOnStartOfSwitchStmt(move(Cond)); 688 } 689 690 /// \brief Attach the body to the switch statement. 691 /// 692 /// By default, performs semantic analysis to build the new statement. 693 /// Subclasses may override this routine to provide different behavior. 694 OwningStmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc, 695 StmtArg Switch, StmtArg Body) { 696 return getSema().ActOnFinishSwitchStmt(SwitchLoc, move(Switch), 697 move(Body)); 698 } 699 700 /// \brief Build a new while statement. 701 /// 702 /// By default, performs semantic analysis to build the new statement. 703 /// Subclasses may override this routine to provide different behavior. 704 OwningStmtResult RebuildWhileStmt(SourceLocation WhileLoc, 705 Sema::FullExprArg Cond, 706 StmtArg Body) { 707 return getSema().ActOnWhileStmt(WhileLoc, Cond, move(Body)); 708 } 709 710 /// \brief Build a new do-while statement. 711 /// 712 /// By default, performs semantic analysis to build the new statement. 713 /// Subclasses may override this routine to provide different behavior. 714 OwningStmtResult RebuildDoStmt(SourceLocation DoLoc, StmtArg Body, 715 SourceLocation WhileLoc, 716 SourceLocation LParenLoc, 717 ExprArg Cond, 718 SourceLocation RParenLoc) { 719 return getSema().ActOnDoStmt(DoLoc, move(Body), WhileLoc, LParenLoc, 720 move(Cond), RParenLoc); 721 } 722 723 /// \brief Build a new for statement. 724 /// 725 /// By default, performs semantic analysis to build the new statement. 726 /// Subclasses may override this routine to provide different behavior. 727 OwningStmtResult RebuildForStmt(SourceLocation ForLoc, 728 SourceLocation LParenLoc, 729 StmtArg Init, ExprArg Cond, ExprArg Inc, 730 SourceLocation RParenLoc, StmtArg Body) { 731 return getSema().ActOnForStmt(ForLoc, LParenLoc, move(Init), move(Cond), 732 move(Inc), RParenLoc, move(Body)); 733 } 734 735 /// \brief Build a new goto statement. 736 /// 737 /// By default, performs semantic analysis to build the new statement. 738 /// Subclasses may override this routine to provide different behavior. 739 OwningStmtResult RebuildGotoStmt(SourceLocation GotoLoc, 740 SourceLocation LabelLoc, 741 LabelStmt *Label) { 742 return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label->getID()); 743 } 744 745 /// \brief Build a new indirect goto statement. 746 /// 747 /// By default, performs semantic analysis to build the new statement. 748 /// Subclasses may override this routine to provide different behavior. 749 OwningStmtResult RebuildIndirectGotoStmt(SourceLocation GotoLoc, 750 SourceLocation StarLoc, 751 ExprArg Target) { 752 return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, move(Target)); 753 } 754 755 /// \brief Build a new return statement. 756 /// 757 /// By default, performs semantic analysis to build the new statement. 758 /// Subclasses may override this routine to provide different behavior. 759 OwningStmtResult RebuildReturnStmt(SourceLocation ReturnLoc, 760 ExprArg Result) { 761 762 return getSema().ActOnReturnStmt(ReturnLoc, move(Result)); 763 } 764 765 /// \brief Build a new declaration statement. 766 /// 767 /// By default, performs semantic analysis to build the new statement. 768 /// Subclasses may override this routine to provide different behavior. 769 OwningStmtResult RebuildDeclStmt(Decl **Decls, unsigned NumDecls, 770 SourceLocation StartLoc, 771 SourceLocation EndLoc) { 772 return getSema().Owned( 773 new (getSema().Context) DeclStmt( 774 DeclGroupRef::Create(getSema().Context, 775 Decls, NumDecls), 776 StartLoc, EndLoc)); 777 } 778 779 /// \brief Build a new C++ exception declaration. 780 /// 781 /// By default, performs semantic analysis to build the new decaration. 782 /// Subclasses may override this routine to provide different behavior. 783 VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl, QualType T, 784 DeclaratorInfo *Declarator, 785 IdentifierInfo *Name, 786 SourceLocation Loc, 787 SourceRange TypeRange) { 788 return getSema().BuildExceptionDeclaration(0, T, Declarator, Name, Loc, 789 TypeRange); 790 } 791 792 /// \brief Build a new C++ catch statement. 793 /// 794 /// By default, performs semantic analysis to build the new statement. 795 /// Subclasses may override this routine to provide different behavior. 796 OwningStmtResult RebuildCXXCatchStmt(SourceLocation CatchLoc, 797 VarDecl *ExceptionDecl, 798 StmtArg Handler) { 799 return getSema().Owned( 800 new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl, 801 Handler.takeAs<Stmt>())); 802 } 803 804 /// \brief Build a new C++ try statement. 805 /// 806 /// By default, performs semantic analysis to build the new statement. 807 /// Subclasses may override this routine to provide different behavior. 808 OwningStmtResult RebuildCXXTryStmt(SourceLocation TryLoc, 809 StmtArg TryBlock, 810 MultiStmtArg Handlers) { 811 return getSema().ActOnCXXTryBlock(TryLoc, move(TryBlock), move(Handlers)); 812 } 813 814 /// \brief Build a new expression that references a declaration. 815 /// 816 /// By default, performs semantic analysis to build the new expression. 817 /// Subclasses may override this routine to provide different behavior. 818 OwningExprResult RebuildDeclRefExpr(NestedNameSpecifier *Qualifier, 819 SourceRange QualifierRange, 820 NamedDecl *ND, SourceLocation Loc, 821 bool isAddressOfOperand) { 822 CXXScopeSpec SS; 823 SS.setScopeRep(Qualifier); 824 SS.setRange(QualifierRange); 825 return getSema().BuildDeclarationNameExpr(Loc, ND, 826 /*FIXME:*/false, 827 &SS, 828 isAddressOfOperand); 829 } 830 831 /// \brief Build a new expression in parentheses. 832 /// 833 /// By default, performs semantic analysis to build the new expression. 834 /// Subclasses may override this routine to provide different behavior. 835 OwningExprResult RebuildParenExpr(ExprArg SubExpr, SourceLocation LParen, 836 SourceLocation RParen) { 837 return getSema().ActOnParenExpr(LParen, RParen, move(SubExpr)); 838 } 839 840 /// \brief Build a new pseudo-destructor expression. 841 /// 842 /// By default, performs semantic analysis to build the new expression. 843 /// Subclasses may override this routine to provide different behavior. 844 OwningExprResult RebuildCXXPseudoDestructorExpr(ExprArg Base, 845 SourceLocation OperatorLoc, 846 bool isArrow, 847 SourceLocation DestroyedTypeLoc, 848 QualType DestroyedType, 849 NestedNameSpecifier *Qualifier, 850 SourceRange QualifierRange) { 851 CXXScopeSpec SS; 852 if (Qualifier) { 853 SS.setRange(QualifierRange); 854 SS.setScopeRep(Qualifier); 855 } 856 857 DeclarationName Name 858 = SemaRef.Context.DeclarationNames.getCXXDestructorName( 859 SemaRef.Context.getCanonicalType(DestroyedType)); 860 861 return getSema().BuildMemberReferenceExpr(/*Scope=*/0, move(Base), 862 OperatorLoc, 863 isArrow? tok::arrow : tok::period, 864 DestroyedTypeLoc, 865 Name, 866 Sema::DeclPtrTy::make((Decl *)0), 867 &SS); 868 } 869 870 /// \brief Build a new unary operator expression. 871 /// 872 /// By default, performs semantic analysis to build the new expression. 873 /// Subclasses may override this routine to provide different behavior. 874 OwningExprResult RebuildUnaryOperator(SourceLocation OpLoc, 875 UnaryOperator::Opcode Opc, 876 ExprArg SubExpr) { 877 return getSema().BuildUnaryOp(/*Scope=*/0, OpLoc, Opc, move(SubExpr)); 878 } 879 880 /// \brief Build a new sizeof or alignof expression with a type argument. 881 /// 882 /// By default, performs semantic analysis to build the new expression. 883 /// Subclasses may override this routine to provide different behavior. 884 OwningExprResult RebuildSizeOfAlignOf(DeclaratorInfo *DInfo, 885 SourceLocation OpLoc, 886 bool isSizeOf, SourceRange R) { 887 return getSema().CreateSizeOfAlignOfExpr(DInfo, OpLoc, isSizeOf, R); 888 } 889 890 /// \brief Build a new sizeof or alignof expression with an expression 891 /// argument. 892 /// 893 /// By default, performs semantic analysis to build the new expression. 894 /// Subclasses may override this routine to provide different behavior. 895 OwningExprResult RebuildSizeOfAlignOf(ExprArg SubExpr, SourceLocation OpLoc, 896 bool isSizeOf, SourceRange R) { 897 OwningExprResult Result 898 = getSema().CreateSizeOfAlignOfExpr((Expr *)SubExpr.get(), 899 OpLoc, isSizeOf, R); 900 if (Result.isInvalid()) 901 return getSema().ExprError(); 902 903 SubExpr.release(); 904 return move(Result); 905 } 906 907 /// \brief Build a new array subscript expression. 908 /// 909 /// By default, performs semantic analysis to build the new expression. 910 /// Subclasses may override this routine to provide different behavior. 911 OwningExprResult RebuildArraySubscriptExpr(ExprArg LHS, 912 SourceLocation LBracketLoc, 913 ExprArg RHS, 914 SourceLocation RBracketLoc) { 915 return getSema().ActOnArraySubscriptExpr(/*Scope=*/0, move(LHS), 916 LBracketLoc, move(RHS), 917 RBracketLoc); 918 } 919 920 /// \brief Build a new call expression. 921 /// 922 /// By default, performs semantic analysis to build the new expression. 923 /// Subclasses may override this routine to provide different behavior. 924 OwningExprResult RebuildCallExpr(ExprArg Callee, SourceLocation LParenLoc, 925 MultiExprArg Args, 926 SourceLocation *CommaLocs, 927 SourceLocation RParenLoc) { 928 return getSema().ActOnCallExpr(/*Scope=*/0, move(Callee), LParenLoc, 929 move(Args), CommaLocs, RParenLoc); 930 } 931 932 /// \brief Build a new member access expression. 933 /// 934 /// By default, performs semantic analysis to build the new expression. 935 /// Subclasses may override this routine to provide different behavior. 936 OwningExprResult RebuildMemberExpr(ExprArg Base, SourceLocation OpLoc, 937 bool isArrow, 938 NestedNameSpecifier *Qualifier, 939 SourceRange QualifierRange, 940 SourceLocation MemberLoc, 941 NamedDecl *Member, 942 const TemplateArgumentListInfo *ExplicitTemplateArgs, 943 NamedDecl *FirstQualifierInScope) { 944 if (!Member->getDeclName()) { 945 // We have a reference to an unnamed field. 946 assert(!Qualifier && "Can't have an unnamed field with a qualifier!"); 947 948 MemberExpr *ME = 949 new (getSema().Context) MemberExpr(Base.takeAs<Expr>(), isArrow, 950 Member, MemberLoc, 951 cast<FieldDecl>(Member)->getType()); 952 return getSema().Owned(ME); 953 } 954 955 CXXScopeSpec SS; 956 if (Qualifier) { 957 SS.setRange(QualifierRange); 958 SS.setScopeRep(Qualifier); 959 } 960 961 return getSema().BuildMemberReferenceExpr(/*Scope=*/0, move(Base), OpLoc, 962 isArrow? tok::arrow : tok::period, 963 MemberLoc, 964 Member->getDeclName(), 965 ExplicitTemplateArgs, 966 /*FIXME?*/Sema::DeclPtrTy::make((Decl*)0), 967 &SS, 968 FirstQualifierInScope); 969 } 970 971 /// \brief Build a new binary operator expression. 972 /// 973 /// By default, performs semantic analysis to build the new expression. 974 /// Subclasses may override this routine to provide different behavior. 975 OwningExprResult RebuildBinaryOperator(SourceLocation OpLoc, 976 BinaryOperator::Opcode Opc, 977 ExprArg LHS, ExprArg RHS) { 978 return getSema().BuildBinOp(/*Scope=*/0, OpLoc, Opc, 979 LHS.takeAs<Expr>(), RHS.takeAs<Expr>()); 980 } 981 982 /// \brief Build a new conditional 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 RebuildConditionalOperator(ExprArg Cond, 987 SourceLocation QuestionLoc, 988 ExprArg LHS, 989 SourceLocation ColonLoc, 990 ExprArg RHS) { 991 return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, move(Cond), 992 move(LHS), move(RHS)); 993 } 994 995 /// \brief Build a new implicit cast expression. 996 /// 997 /// By default, builds a new implicit cast without any semantic analysis. 998 /// Subclasses may override this routine to provide different behavior. 999 OwningExprResult RebuildImplicitCastExpr(QualType T, CastExpr::CastKind Kind, 1000 ExprArg SubExpr, bool isLvalue) { 1001 ImplicitCastExpr *ICE 1002 = new (getSema().Context) ImplicitCastExpr(T, Kind, 1003 (Expr *)SubExpr.release(), 1004 isLvalue); 1005 return getSema().Owned(ICE); 1006 } 1007 1008 /// \brief Build a new C-style cast expression. 1009 /// 1010 /// By default, performs semantic analysis to build the new expression. 1011 /// Subclasses may override this routine to provide different behavior. 1012 OwningExprResult RebuildCStyleCaseExpr(SourceLocation LParenLoc, 1013 QualType ExplicitTy, 1014 SourceLocation RParenLoc, 1015 ExprArg SubExpr) { 1016 return getSema().ActOnCastExpr(/*Scope=*/0, 1017 LParenLoc, 1018 ExplicitTy.getAsOpaquePtr(), 1019 RParenLoc, 1020 move(SubExpr)); 1021 } 1022 1023 /// \brief Build a new compound literal expression. 1024 /// 1025 /// By default, performs semantic analysis to build the new expression. 1026 /// Subclasses may override this routine to provide different behavior. 1027 OwningExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc, 1028 QualType T, 1029 SourceLocation RParenLoc, 1030 ExprArg Init) { 1031 return getSema().ActOnCompoundLiteral(LParenLoc, T.getAsOpaquePtr(), 1032 RParenLoc, move(Init)); 1033 } 1034 1035 /// \brief Build a new extended vector element access expression. 1036 /// 1037 /// By default, performs semantic analysis to build the new expression. 1038 /// Subclasses may override this routine to provide different behavior. 1039 OwningExprResult RebuildExtVectorElementExpr(ExprArg Base, 1040 SourceLocation OpLoc, 1041 SourceLocation AccessorLoc, 1042 IdentifierInfo &Accessor) { 1043 return getSema().BuildMemberReferenceExpr(/*Scope=*/0, move(Base), OpLoc, 1044 tok::period, AccessorLoc, 1045 DeclarationName(&Accessor), 1046 /*FIXME?*/Sema::DeclPtrTy::make((Decl*)0)); 1047 } 1048 1049 /// \brief Build a new initializer list expression. 1050 /// 1051 /// By default, performs semantic analysis to build the new expression. 1052 /// Subclasses may override this routine to provide different behavior. 1053 OwningExprResult RebuildInitList(SourceLocation LBraceLoc, 1054 MultiExprArg Inits, 1055 SourceLocation RBraceLoc, 1056 QualType ResultTy) { 1057 OwningExprResult Result 1058 = SemaRef.ActOnInitList(LBraceLoc, move(Inits), RBraceLoc); 1059 if (Result.isInvalid() || ResultTy->isDependentType()) 1060 return move(Result); 1061 1062 // Patch in the result type we were given, which may have been computed 1063 // when the initial InitListExpr was built. 1064 InitListExpr *ILE = cast<InitListExpr>((Expr *)Result.get()); 1065 ILE->setType(ResultTy); 1066 return move(Result); 1067 } 1068 1069 /// \brief Build a new designated initializer expression. 1070 /// 1071 /// By default, performs semantic analysis to build the new expression. 1072 /// Subclasses may override this routine to provide different behavior. 1073 OwningExprResult RebuildDesignatedInitExpr(Designation &Desig, 1074 MultiExprArg ArrayExprs, 1075 SourceLocation EqualOrColonLoc, 1076 bool GNUSyntax, 1077 ExprArg Init) { 1078 OwningExprResult Result 1079 = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax, 1080 move(Init)); 1081 if (Result.isInvalid()) 1082 return SemaRef.ExprError(); 1083 1084 ArrayExprs.release(); 1085 return move(Result); 1086 } 1087 1088 /// \brief Build a new value-initialized expression. 1089 /// 1090 /// By default, builds the implicit value initialization without performing 1091 /// any semantic analysis. Subclasses may override this routine to provide 1092 /// different behavior. 1093 OwningExprResult RebuildImplicitValueInitExpr(QualType T) { 1094 return SemaRef.Owned(new (SemaRef.Context) ImplicitValueInitExpr(T)); 1095 } 1096 1097 /// \brief Build a new \c va_arg expression. 1098 /// 1099 /// By default, performs semantic analysis to build the new expression. 1100 /// Subclasses may override this routine to provide different behavior. 1101 OwningExprResult RebuildVAArgExpr(SourceLocation BuiltinLoc, ExprArg SubExpr, 1102 QualType T, SourceLocation RParenLoc) { 1103 return getSema().ActOnVAArg(BuiltinLoc, move(SubExpr), T.getAsOpaquePtr(), 1104 RParenLoc); 1105 } 1106 1107 /// \brief Build a new expression list in parentheses. 1108 /// 1109 /// By default, performs semantic analysis to build the new expression. 1110 /// Subclasses may override this routine to provide different behavior. 1111 OwningExprResult RebuildParenListExpr(SourceLocation LParenLoc, 1112 MultiExprArg SubExprs, 1113 SourceLocation RParenLoc) { 1114 return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, move(SubExprs)); 1115 } 1116 1117 /// \brief Build a new address-of-label expression. 1118 /// 1119 /// By default, performs semantic analysis, using the name of the label 1120 /// rather than attempting to map the label statement itself. 1121 /// Subclasses may override this routine to provide different behavior. 1122 OwningExprResult RebuildAddrLabelExpr(SourceLocation AmpAmpLoc, 1123 SourceLocation LabelLoc, 1124 LabelStmt *Label) { 1125 return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label->getID()); 1126 } 1127 1128 /// \brief Build a new GNU statement expression. 1129 /// 1130 /// By default, performs semantic analysis to build the new expression. 1131 /// Subclasses may override this routine to provide different behavior. 1132 OwningExprResult RebuildStmtExpr(SourceLocation LParenLoc, 1133 StmtArg SubStmt, 1134 SourceLocation RParenLoc) { 1135 return getSema().ActOnStmtExpr(LParenLoc, move(SubStmt), RParenLoc); 1136 } 1137 1138 /// \brief Build a new __builtin_types_compatible_p expression. 1139 /// 1140 /// By default, performs semantic analysis to build the new expression. 1141 /// Subclasses may override this routine to provide different behavior. 1142 OwningExprResult RebuildTypesCompatibleExpr(SourceLocation BuiltinLoc, 1143 QualType T1, QualType T2, 1144 SourceLocation RParenLoc) { 1145 return getSema().ActOnTypesCompatibleExpr(BuiltinLoc, 1146 T1.getAsOpaquePtr(), 1147 T2.getAsOpaquePtr(), 1148 RParenLoc); 1149 } 1150 1151 /// \brief Build a new __builtin_choose_expr expression. 1152 /// 1153 /// By default, performs semantic analysis to build the new expression. 1154 /// Subclasses may override this routine to provide different behavior. 1155 OwningExprResult RebuildChooseExpr(SourceLocation BuiltinLoc, 1156 ExprArg Cond, ExprArg LHS, ExprArg RHS, 1157 SourceLocation RParenLoc) { 1158 return SemaRef.ActOnChooseExpr(BuiltinLoc, 1159 move(Cond), move(LHS), move(RHS), 1160 RParenLoc); 1161 } 1162 1163 /// \brief Build a new overloaded operator call expression. 1164 /// 1165 /// By default, performs semantic analysis to build the new expression. 1166 /// The semantic analysis provides the behavior of template instantiation, 1167 /// copying with transformations that turn what looks like an overloaded 1168 /// operator call into a use of a builtin operator, performing 1169 /// argument-dependent lookup, etc. Subclasses may override this routine to 1170 /// provide different behavior. 1171 OwningExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, 1172 SourceLocation OpLoc, 1173 ExprArg Callee, 1174 ExprArg First, 1175 ExprArg Second); 1176 1177 /// \brief Build a new C++ "named" cast expression, such as static_cast or 1178 /// reinterpret_cast. 1179 /// 1180 /// By default, this routine dispatches to one of the more-specific routines 1181 /// for a particular named case, e.g., RebuildCXXStaticCastExpr(). 1182 /// Subclasses may override this routine to provide different behavior. 1183 OwningExprResult RebuildCXXNamedCastExpr(SourceLocation OpLoc, 1184 Stmt::StmtClass Class, 1185 SourceLocation LAngleLoc, 1186 QualType T, 1187 SourceLocation RAngleLoc, 1188 SourceLocation LParenLoc, 1189 ExprArg SubExpr, 1190 SourceLocation RParenLoc) { 1191 switch (Class) { 1192 case Stmt::CXXStaticCastExprClass: 1193 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, T, 1194 RAngleLoc, LParenLoc, 1195 move(SubExpr), RParenLoc); 1196 1197 case Stmt::CXXDynamicCastExprClass: 1198 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, T, 1199 RAngleLoc, LParenLoc, 1200 move(SubExpr), RParenLoc); 1201 1202 case Stmt::CXXReinterpretCastExprClass: 1203 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, T, 1204 RAngleLoc, LParenLoc, 1205 move(SubExpr), 1206 RParenLoc); 1207 1208 case Stmt::CXXConstCastExprClass: 1209 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, T, 1210 RAngleLoc, LParenLoc, 1211 move(SubExpr), RParenLoc); 1212 1213 default: 1214 assert(false && "Invalid C++ named cast"); 1215 break; 1216 } 1217 1218 return getSema().ExprError(); 1219 } 1220 1221 /// \brief Build a new C++ static_cast expression. 1222 /// 1223 /// By default, performs semantic analysis to build the new expression. 1224 /// Subclasses may override this routine to provide different behavior. 1225 OwningExprResult RebuildCXXStaticCastExpr(SourceLocation OpLoc, 1226 SourceLocation LAngleLoc, 1227 QualType T, 1228 SourceLocation RAngleLoc, 1229 SourceLocation LParenLoc, 1230 ExprArg SubExpr, 1231 SourceLocation RParenLoc) { 1232 return getSema().ActOnCXXNamedCast(OpLoc, tok::kw_static_cast, 1233 LAngleLoc, T.getAsOpaquePtr(), RAngleLoc, 1234 LParenLoc, move(SubExpr), RParenLoc); 1235 } 1236 1237 /// \brief Build a new C++ dynamic_cast expression. 1238 /// 1239 /// By default, performs semantic analysis to build the new expression. 1240 /// Subclasses may override this routine to provide different behavior. 1241 OwningExprResult RebuildCXXDynamicCastExpr(SourceLocation OpLoc, 1242 SourceLocation LAngleLoc, 1243 QualType T, 1244 SourceLocation RAngleLoc, 1245 SourceLocation LParenLoc, 1246 ExprArg SubExpr, 1247 SourceLocation RParenLoc) { 1248 return getSema().ActOnCXXNamedCast(OpLoc, tok::kw_dynamic_cast, 1249 LAngleLoc, T.getAsOpaquePtr(), RAngleLoc, 1250 LParenLoc, move(SubExpr), RParenLoc); 1251 } 1252 1253 /// \brief Build a new C++ reinterpret_cast expression. 1254 /// 1255 /// By default, performs semantic analysis to build the new expression. 1256 /// Subclasses may override this routine to provide different behavior. 1257 OwningExprResult RebuildCXXReinterpretCastExpr(SourceLocation OpLoc, 1258 SourceLocation LAngleLoc, 1259 QualType T, 1260 SourceLocation RAngleLoc, 1261 SourceLocation LParenLoc, 1262 ExprArg SubExpr, 1263 SourceLocation RParenLoc) { 1264 return getSema().ActOnCXXNamedCast(OpLoc, tok::kw_reinterpret_cast, 1265 LAngleLoc, T.getAsOpaquePtr(), RAngleLoc, 1266 LParenLoc, move(SubExpr), RParenLoc); 1267 } 1268 1269 /// \brief Build a new C++ const_cast expression. 1270 /// 1271 /// By default, performs semantic analysis to build the new expression. 1272 /// Subclasses may override this routine to provide different behavior. 1273 OwningExprResult RebuildCXXConstCastExpr(SourceLocation OpLoc, 1274 SourceLocation LAngleLoc, 1275 QualType T, 1276 SourceLocation RAngleLoc, 1277 SourceLocation LParenLoc, 1278 ExprArg SubExpr, 1279 SourceLocation RParenLoc) { 1280 return getSema().ActOnCXXNamedCast(OpLoc, tok::kw_const_cast, 1281 LAngleLoc, T.getAsOpaquePtr(), RAngleLoc, 1282 LParenLoc, move(SubExpr), RParenLoc); 1283 } 1284 1285 /// \brief Build a new C++ functional-style cast expression. 1286 /// 1287 /// By default, performs semantic analysis to build the new expression. 1288 /// Subclasses may override this routine to provide different behavior. 1289 OwningExprResult RebuildCXXFunctionalCastExpr(SourceRange TypeRange, 1290 QualType T, 1291 SourceLocation LParenLoc, 1292 ExprArg SubExpr, 1293 SourceLocation RParenLoc) { 1294 void *Sub = SubExpr.takeAs<Expr>(); 1295 return getSema().ActOnCXXTypeConstructExpr(TypeRange, 1296 T.getAsOpaquePtr(), 1297 LParenLoc, 1298 Sema::MultiExprArg(getSema(), &Sub, 1), 1299 /*CommaLocs=*/0, 1300 RParenLoc); 1301 } 1302 1303 /// \brief Build a new C++ typeid(type) expression. 1304 /// 1305 /// By default, performs semantic analysis to build the new expression. 1306 /// Subclasses may override this routine to provide different behavior. 1307 OwningExprResult RebuildCXXTypeidExpr(SourceLocation TypeidLoc, 1308 SourceLocation LParenLoc, 1309 QualType T, 1310 SourceLocation RParenLoc) { 1311 return getSema().ActOnCXXTypeid(TypeidLoc, LParenLoc, true, 1312 T.getAsOpaquePtr(), RParenLoc); 1313 } 1314 1315 /// \brief Build a new C++ typeid(expr) expression. 1316 /// 1317 /// By default, performs semantic analysis to build the new expression. 1318 /// Subclasses may override this routine to provide different behavior. 1319 OwningExprResult RebuildCXXTypeidExpr(SourceLocation TypeidLoc, 1320 SourceLocation LParenLoc, 1321 ExprArg Operand, 1322 SourceLocation RParenLoc) { 1323 OwningExprResult Result 1324 = getSema().ActOnCXXTypeid(TypeidLoc, LParenLoc, false, Operand.get(), 1325 RParenLoc); 1326 if (Result.isInvalid()) 1327 return getSema().ExprError(); 1328 1329 Operand.release(); // FIXME: since ActOnCXXTypeid silently took ownership 1330 return move(Result); 1331 } 1332 1333 /// \brief Build a new C++ "this" expression. 1334 /// 1335 /// By default, builds a new "this" expression without performing any 1336 /// semantic analysis. Subclasses may override this routine to provide 1337 /// different behavior. 1338 OwningExprResult RebuildCXXThisExpr(SourceLocation ThisLoc, 1339 QualType ThisType) { 1340 return getSema().Owned( 1341 new (getSema().Context) CXXThisExpr(ThisLoc, ThisType)); 1342 } 1343 1344 /// \brief Build a new C++ throw expression. 1345 /// 1346 /// By default, performs semantic analysis to build the new expression. 1347 /// Subclasses may override this routine to provide different behavior. 1348 OwningExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, ExprArg Sub) { 1349 return getSema().ActOnCXXThrow(ThrowLoc, move(Sub)); 1350 } 1351 1352 /// \brief Build a new C++ default-argument expression. 1353 /// 1354 /// By default, builds a new default-argument expression, which does not 1355 /// require any semantic analysis. Subclasses may override this routine to 1356 /// provide different behavior. 1357 OwningExprResult RebuildCXXDefaultArgExpr(ParmVarDecl *Param) { 1358 return getSema().Owned(CXXDefaultArgExpr::Create(getSema().Context, Param)); 1359 } 1360 1361 /// \brief Build a new C++ zero-initialization expression. 1362 /// 1363 /// By default, performs semantic analysis to build the new expression. 1364 /// Subclasses may override this routine to provide different behavior. 1365 OwningExprResult RebuildCXXZeroInitValueExpr(SourceLocation TypeStartLoc, 1366 SourceLocation LParenLoc, 1367 QualType T, 1368 SourceLocation RParenLoc) { 1369 return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeStartLoc), 1370 T.getAsOpaquePtr(), LParenLoc, 1371 MultiExprArg(getSema(), 0, 0), 1372 0, RParenLoc); 1373 } 1374 1375 /// \brief Build a new C++ conditional declaration expression. 1376 /// 1377 /// By default, performs semantic analysis to build the new expression. 1378 /// Subclasses may override this routine to provide different behavior. 1379 OwningExprResult RebuildCXXConditionDeclExpr(SourceLocation StartLoc, 1380 SourceLocation EqLoc, 1381 VarDecl *Var) { 1382 return SemaRef.Owned(new (SemaRef.Context) CXXConditionDeclExpr(StartLoc, 1383 EqLoc, 1384 Var)); 1385 } 1386 1387 /// \brief Build a new C++ "new" expression. 1388 /// 1389 /// By default, performs semantic analysis to build the new expression. 1390 /// Subclasses may override this routine to provide different behavior. 1391 OwningExprResult RebuildCXXNewExpr(SourceLocation StartLoc, 1392 bool UseGlobal, 1393 SourceLocation PlacementLParen, 1394 MultiExprArg PlacementArgs, 1395 SourceLocation PlacementRParen, 1396 bool ParenTypeId, 1397 QualType AllocType, 1398 SourceLocation TypeLoc, 1399 SourceRange TypeRange, 1400 ExprArg ArraySize, 1401 SourceLocation ConstructorLParen, 1402 MultiExprArg ConstructorArgs, 1403 SourceLocation ConstructorRParen) { 1404 return getSema().BuildCXXNew(StartLoc, UseGlobal, 1405 PlacementLParen, 1406 move(PlacementArgs), 1407 PlacementRParen, 1408 ParenTypeId, 1409 AllocType, 1410 TypeLoc, 1411 TypeRange, 1412 move(ArraySize), 1413 ConstructorLParen, 1414 move(ConstructorArgs), 1415 ConstructorRParen); 1416 } 1417 1418 /// \brief Build a new C++ "delete" expression. 1419 /// 1420 /// By default, performs semantic analysis to build the new expression. 1421 /// Subclasses may override this routine to provide different behavior. 1422 OwningExprResult RebuildCXXDeleteExpr(SourceLocation StartLoc, 1423 bool IsGlobalDelete, 1424 bool IsArrayForm, 1425 ExprArg Operand) { 1426 return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm, 1427 move(Operand)); 1428 } 1429 1430 /// \brief Build a new unary type trait expression. 1431 /// 1432 /// By default, performs semantic analysis to build the new expression. 1433 /// Subclasses may override this routine to provide different behavior. 1434 OwningExprResult RebuildUnaryTypeTrait(UnaryTypeTrait Trait, 1435 SourceLocation StartLoc, 1436 SourceLocation LParenLoc, 1437 QualType T, 1438 SourceLocation RParenLoc) { 1439 return getSema().ActOnUnaryTypeTrait(Trait, StartLoc, LParenLoc, 1440 T.getAsOpaquePtr(), RParenLoc); 1441 } 1442 1443 /// \brief Build a new (previously unresolved) declaration reference 1444 /// expression. 1445 /// 1446 /// By default, performs semantic analysis to build the new expression. 1447 /// Subclasses may override this routine to provide different behavior. 1448 OwningExprResult RebuildDependentScopeDeclRefExpr(NestedNameSpecifier *NNS, 1449 SourceRange QualifierRange, 1450 DeclarationName Name, 1451 SourceLocation Location, 1452 bool IsAddressOfOperand) { 1453 CXXScopeSpec SS; 1454 SS.setRange(QualifierRange); 1455 SS.setScopeRep(NNS); 1456 return getSema().ActOnDeclarationNameExpr(/*Scope=*/0, 1457 Location, 1458 Name, 1459 /*Trailing lparen=*/false, 1460 &SS, 1461 IsAddressOfOperand); 1462 } 1463 1464 /// \brief Build a new template-id expression. 1465 /// 1466 /// By default, performs semantic analysis to build the new expression. 1467 /// Subclasses may override this routine to provide different behavior. 1468 OwningExprResult RebuildTemplateIdExpr(NestedNameSpecifier *Qualifier, 1469 SourceRange QualifierRange, 1470 TemplateName Template, 1471 SourceLocation TemplateLoc, 1472 const TemplateArgumentListInfo &TemplateArgs) { 1473 return getSema().BuildTemplateIdExpr(Qualifier, QualifierRange, 1474 Template, TemplateLoc, TemplateArgs); 1475 } 1476 1477 /// \brief Build a new object-construction expression. 1478 /// 1479 /// By default, performs semantic analysis to build the new expression. 1480 /// Subclasses may override this routine to provide different behavior. 1481 OwningExprResult RebuildCXXConstructExpr(QualType T, 1482 CXXConstructorDecl *Constructor, 1483 bool IsElidable, 1484 MultiExprArg Args) { 1485 return getSema().BuildCXXConstructExpr(/*FIXME:ConstructLoc*/ 1486 SourceLocation(), 1487 T, Constructor, IsElidable, 1488 move(Args)); 1489 } 1490 1491 /// \brief Build a new object-construction expression. 1492 /// 1493 /// By default, performs semantic analysis to build the new expression. 1494 /// Subclasses may override this routine to provide different behavior. 1495 OwningExprResult RebuildCXXTemporaryObjectExpr(SourceLocation TypeBeginLoc, 1496 QualType T, 1497 SourceLocation LParenLoc, 1498 MultiExprArg Args, 1499 SourceLocation *Commas, 1500 SourceLocation RParenLoc) { 1501 return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeBeginLoc), 1502 T.getAsOpaquePtr(), 1503 LParenLoc, 1504 move(Args), 1505 Commas, 1506 RParenLoc); 1507 } 1508 1509 /// \brief Build a new object-construction expression. 1510 /// 1511 /// By default, performs semantic analysis to build the new expression. 1512 /// Subclasses may override this routine to provide different behavior. 1513 OwningExprResult RebuildCXXUnresolvedConstructExpr(SourceLocation TypeBeginLoc, 1514 QualType T, 1515 SourceLocation LParenLoc, 1516 MultiExprArg Args, 1517 SourceLocation *Commas, 1518 SourceLocation RParenLoc) { 1519 return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeBeginLoc, 1520 /*FIXME*/LParenLoc), 1521 T.getAsOpaquePtr(), 1522 LParenLoc, 1523 move(Args), 1524 Commas, 1525 RParenLoc); 1526 } 1527 1528 /// \brief Build a new member reference expression. 1529 /// 1530 /// By default, performs semantic analysis to build the new expression. 1531 /// Subclasses may override this routine to provide different behavior. 1532 OwningExprResult RebuildCXXDependentScopeMemberExpr(ExprArg BaseE, 1533 bool IsArrow, 1534 SourceLocation OperatorLoc, 1535 NestedNameSpecifier *Qualifier, 1536 SourceRange QualifierRange, 1537 DeclarationName Name, 1538 SourceLocation MemberLoc, 1539 NamedDecl *FirstQualifierInScope) { 1540 OwningExprResult Base = move(BaseE); 1541 tok::TokenKind OpKind = IsArrow? tok::arrow : tok::period; 1542 1543 CXXScopeSpec SS; 1544 SS.setRange(QualifierRange); 1545 SS.setScopeRep(Qualifier); 1546 1547 return SemaRef.BuildMemberReferenceExpr(/*Scope=*/0, 1548 move(Base), OperatorLoc, OpKind, 1549 MemberLoc, 1550 Name, 1551 /*FIXME?*/Sema::DeclPtrTy::make((Decl*)0), 1552 &SS, 1553 FirstQualifierInScope); 1554 } 1555 1556 /// \brief Build a new member reference expression with explicit template 1557 /// arguments. 1558 /// 1559 /// By default, performs semantic analysis to build the new expression. 1560 /// Subclasses may override this routine to provide different behavior. 1561 OwningExprResult RebuildCXXDependentScopeMemberExpr(ExprArg BaseE, 1562 bool IsArrow, 1563 SourceLocation OperatorLoc, 1564 NestedNameSpecifier *Qualifier, 1565 SourceRange QualifierRange, 1566 TemplateName Template, 1567 SourceLocation TemplateNameLoc, 1568 NamedDecl *FirstQualifierInScope, 1569 const TemplateArgumentListInfo &TemplateArgs) { 1570 OwningExprResult Base = move(BaseE); 1571 tok::TokenKind OpKind = IsArrow? tok::arrow : tok::period; 1572 1573 CXXScopeSpec SS; 1574 SS.setRange(QualifierRange); 1575 SS.setScopeRep(Qualifier); 1576 1577 // FIXME: We're going to end up looking up the template based on its name, 1578 // twice! Also, duplicates part of Sema::BuildMemberAccessExpr. 1579 DeclarationName Name; 1580 if (TemplateDecl *ActualTemplate = Template.getAsTemplateDecl()) 1581 Name = ActualTemplate->getDeclName(); 1582 else if (OverloadedFunctionDecl *Ovl 1583 = Template.getAsOverloadedFunctionDecl()) 1584 Name = Ovl->getDeclName(); 1585 else { 1586 DependentTemplateName *DTN = Template.getAsDependentTemplateName(); 1587 if (DTN->isIdentifier()) 1588 Name = DTN->getIdentifier(); 1589 else 1590 Name = SemaRef.Context.DeclarationNames.getCXXOperatorName( 1591 DTN->getOperator()); 1592 } 1593 return SemaRef.BuildMemberReferenceExpr(/*Scope=*/0, move(Base), 1594 OperatorLoc, OpKind, 1595 TemplateNameLoc, Name, 1596 &TemplateArgs, 1597 Sema::DeclPtrTy(), &SS); 1598 } 1599 1600 /// \brief Build a new Objective-C @encode expression. 1601 /// 1602 /// By default, performs semantic analysis to build the new expression. 1603 /// Subclasses may override this routine to provide different behavior. 1604 OwningExprResult RebuildObjCEncodeExpr(SourceLocation AtLoc, 1605 QualType T, 1606 SourceLocation RParenLoc) { 1607 return SemaRef.Owned(SemaRef.BuildObjCEncodeExpression(AtLoc, T, 1608 RParenLoc)); 1609 } 1610 1611 /// \brief Build a new Objective-C protocol expression. 1612 /// 1613 /// By default, performs semantic analysis to build the new expression. 1614 /// Subclasses may override this routine to provide different behavior. 1615 OwningExprResult RebuildObjCProtocolExpr(ObjCProtocolDecl *Protocol, 1616 SourceLocation AtLoc, 1617 SourceLocation ProtoLoc, 1618 SourceLocation LParenLoc, 1619 SourceLocation RParenLoc) { 1620 return SemaRef.Owned(SemaRef.ParseObjCProtocolExpression( 1621 Protocol->getIdentifier(), 1622 AtLoc, 1623 ProtoLoc, 1624 LParenLoc, 1625 RParenLoc)); 1626 } 1627 1628 /// \brief Build a new shuffle vector expression. 1629 /// 1630 /// By default, performs semantic analysis to build the new expression. 1631 /// Subclasses may override this routine to provide different behavior. 1632 OwningExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc, 1633 MultiExprArg SubExprs, 1634 SourceLocation RParenLoc) { 1635 // Find the declaration for __builtin_shufflevector 1636 const IdentifierInfo &Name 1637 = SemaRef.Context.Idents.get("__builtin_shufflevector"); 1638 TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl(); 1639 DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name)); 1640 assert(Lookup.first != Lookup.second && "No __builtin_shufflevector?"); 1641 1642 // Build a reference to the __builtin_shufflevector builtin 1643 FunctionDecl *Builtin = cast<FunctionDecl>(*Lookup.first); 1644 Expr *Callee 1645 = new (SemaRef.Context) DeclRefExpr(Builtin, Builtin->getType(), 1646 BuiltinLoc); 1647 SemaRef.UsualUnaryConversions(Callee); 1648 1649 // Build the CallExpr 1650 unsigned NumSubExprs = SubExprs.size(); 1651 Expr **Subs = (Expr **)SubExprs.release(); 1652 CallExpr *TheCall = new (SemaRef.Context) CallExpr(SemaRef.Context, Callee, 1653 Subs, NumSubExprs, 1654 Builtin->getResultType(), 1655 RParenLoc); 1656 OwningExprResult OwnedCall(SemaRef.Owned(TheCall)); 1657 1658 // Type-check the __builtin_shufflevector expression. 1659 OwningExprResult Result = SemaRef.SemaBuiltinShuffleVector(TheCall); 1660 if (Result.isInvalid()) 1661 return SemaRef.ExprError(); 1662 1663 OwnedCall.release(); 1664 return move(Result); 1665 } 1666}; 1667 1668template<typename Derived> 1669Sema::OwningStmtResult TreeTransform<Derived>::TransformStmt(Stmt *S) { 1670 if (!S) 1671 return SemaRef.Owned(S); 1672 1673 switch (S->getStmtClass()) { 1674 case Stmt::NoStmtClass: break; 1675 1676 // Transform individual statement nodes 1677#define STMT(Node, Parent) \ 1678 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S)); 1679#define EXPR(Node, Parent) 1680#include "clang/AST/StmtNodes.def" 1681 1682 // Transform expressions by calling TransformExpr. 1683#define STMT(Node, Parent) 1684#define EXPR(Node, Parent) case Stmt::Node##Class: 1685#include "clang/AST/StmtNodes.def" 1686 { 1687 Sema::OwningExprResult E = getDerived().TransformExpr(cast<Expr>(S)); 1688 if (E.isInvalid()) 1689 return getSema().StmtError(); 1690 1691 return getSema().ActOnExprStmt(getSema().FullExpr(E)); 1692 } 1693 } 1694 1695 return SemaRef.Owned(S->Retain()); 1696} 1697 1698 1699template<typename Derived> 1700Sema::OwningExprResult TreeTransform<Derived>::TransformExpr(Expr *E, 1701 bool isAddressOfOperand) { 1702 if (!E) 1703 return SemaRef.Owned(E); 1704 1705 switch (E->getStmtClass()) { 1706 case Stmt::NoStmtClass: break; 1707#define STMT(Node, Parent) case Stmt::Node##Class: break; 1708#define EXPR(Node, Parent) \ 1709 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E), \ 1710 isAddressOfOperand); 1711#include "clang/AST/StmtNodes.def" 1712 } 1713 1714 return SemaRef.Owned(E->Retain()); 1715} 1716 1717template<typename Derived> 1718NestedNameSpecifier * 1719TreeTransform<Derived>::TransformNestedNameSpecifier(NestedNameSpecifier *NNS, 1720 SourceRange Range, 1721 QualType ObjectType, 1722 NamedDecl *FirstQualifierInScope) { 1723 if (!NNS) 1724 return 0; 1725 1726 // Transform the prefix of this nested name specifier. 1727 NestedNameSpecifier *Prefix = NNS->getPrefix(); 1728 if (Prefix) { 1729 Prefix = getDerived().TransformNestedNameSpecifier(Prefix, Range, 1730 ObjectType, 1731 FirstQualifierInScope); 1732 if (!Prefix) 1733 return 0; 1734 1735 // Clear out the object type and the first qualifier in scope; they only 1736 // apply to the first element in the nested-name-specifier. 1737 ObjectType = QualType(); 1738 FirstQualifierInScope = 0; 1739 } 1740 1741 switch (NNS->getKind()) { 1742 case NestedNameSpecifier::Identifier: 1743 assert((Prefix || !ObjectType.isNull()) && 1744 "Identifier nested-name-specifier with no prefix or object type"); 1745 if (!getDerived().AlwaysRebuild() && Prefix == NNS->getPrefix() && 1746 ObjectType.isNull()) 1747 return NNS; 1748 1749 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, 1750 *NNS->getAsIdentifier(), 1751 ObjectType, 1752 FirstQualifierInScope); 1753 1754 case NestedNameSpecifier::Namespace: { 1755 NamespaceDecl *NS 1756 = cast_or_null<NamespaceDecl>( 1757 getDerived().TransformDecl(NNS->getAsNamespace())); 1758 if (!getDerived().AlwaysRebuild() && 1759 Prefix == NNS->getPrefix() && 1760 NS == NNS->getAsNamespace()) 1761 return NNS; 1762 1763 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, NS); 1764 } 1765 1766 case NestedNameSpecifier::Global: 1767 // There is no meaningful transformation that one could perform on the 1768 // global scope. 1769 return NNS; 1770 1771 case NestedNameSpecifier::TypeSpecWithTemplate: 1772 case NestedNameSpecifier::TypeSpec: { 1773 TemporaryBase Rebase(*this, Range.getBegin(), DeclarationName()); 1774 QualType T = getDerived().TransformType(QualType(NNS->getAsType(), 0)); 1775 if (T.isNull()) 1776 return 0; 1777 1778 if (!getDerived().AlwaysRebuild() && 1779 Prefix == NNS->getPrefix() && 1780 T == QualType(NNS->getAsType(), 0)) 1781 return NNS; 1782 1783 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, 1784 NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate, 1785 T); 1786 } 1787 } 1788 1789 // Required to silence a GCC warning 1790 return 0; 1791} 1792 1793template<typename Derived> 1794DeclarationName 1795TreeTransform<Derived>::TransformDeclarationName(DeclarationName Name, 1796 SourceLocation Loc, 1797 QualType ObjectType) { 1798 if (!Name) 1799 return Name; 1800 1801 switch (Name.getNameKind()) { 1802 case DeclarationName::Identifier: 1803 case DeclarationName::ObjCZeroArgSelector: 1804 case DeclarationName::ObjCOneArgSelector: 1805 case DeclarationName::ObjCMultiArgSelector: 1806 case DeclarationName::CXXOperatorName: 1807 case DeclarationName::CXXUsingDirective: 1808 return Name; 1809 1810 case DeclarationName::CXXConstructorName: 1811 case DeclarationName::CXXDestructorName: 1812 case DeclarationName::CXXConversionFunctionName: { 1813 TemporaryBase Rebase(*this, Loc, Name); 1814 QualType T; 1815 if (!ObjectType.isNull() && 1816 isa<TemplateSpecializationType>(Name.getCXXNameType())) { 1817 TemplateSpecializationType *SpecType 1818 = cast<TemplateSpecializationType>(Name.getCXXNameType()); 1819 T = TransformTemplateSpecializationType(SpecType, ObjectType); 1820 } else 1821 T = getDerived().TransformType(Name.getCXXNameType()); 1822 if (T.isNull()) 1823 return DeclarationName(); 1824 1825 return SemaRef.Context.DeclarationNames.getCXXSpecialName( 1826 Name.getNameKind(), 1827 SemaRef.Context.getCanonicalType(T)); 1828 } 1829 } 1830 1831 return DeclarationName(); 1832} 1833 1834template<typename Derived> 1835TemplateName 1836TreeTransform<Derived>::TransformTemplateName(TemplateName Name, 1837 QualType ObjectType) { 1838 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) { 1839 NestedNameSpecifier *NNS 1840 = getDerived().TransformNestedNameSpecifier(QTN->getQualifier(), 1841 /*FIXME:*/SourceRange(getDerived().getBaseLocation())); 1842 if (!NNS) 1843 return TemplateName(); 1844 1845 if (TemplateDecl *Template = QTN->getTemplateDecl()) { 1846 TemplateDecl *TransTemplate 1847 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Template)); 1848 if (!TransTemplate) 1849 return TemplateName(); 1850 1851 if (!getDerived().AlwaysRebuild() && 1852 NNS == QTN->getQualifier() && 1853 TransTemplate == Template) 1854 return Name; 1855 1856 return getDerived().RebuildTemplateName(NNS, QTN->hasTemplateKeyword(), 1857 TransTemplate); 1858 } 1859 1860 OverloadedFunctionDecl *Ovl = QTN->getOverloadedFunctionDecl(); 1861 assert(Ovl && "Not a template name or an overload set?"); 1862 OverloadedFunctionDecl *TransOvl 1863 = cast_or_null<OverloadedFunctionDecl>(getDerived().TransformDecl(Ovl)); 1864 if (!TransOvl) 1865 return TemplateName(); 1866 1867 if (!getDerived().AlwaysRebuild() && 1868 NNS == QTN->getQualifier() && 1869 TransOvl == Ovl) 1870 return Name; 1871 1872 return getDerived().RebuildTemplateName(NNS, QTN->hasTemplateKeyword(), 1873 TransOvl); 1874 } 1875 1876 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) { 1877 NestedNameSpecifier *NNS 1878 = getDerived().TransformNestedNameSpecifier(DTN->getQualifier(), 1879 /*FIXME:*/SourceRange(getDerived().getBaseLocation())); 1880 if (!NNS && DTN->getQualifier()) 1881 return TemplateName(); 1882 1883 if (!getDerived().AlwaysRebuild() && 1884 NNS == DTN->getQualifier() && 1885 ObjectType.isNull()) 1886 return Name; 1887 1888 if (DTN->isIdentifier()) 1889 return getDerived().RebuildTemplateName(NNS, *DTN->getIdentifier(), 1890 ObjectType); 1891 1892 return getDerived().RebuildTemplateName(NNS, DTN->getOperator(), 1893 ObjectType); 1894 } 1895 1896 if (TemplateDecl *Template = Name.getAsTemplateDecl()) { 1897 TemplateDecl *TransTemplate 1898 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Template)); 1899 if (!TransTemplate) 1900 return TemplateName(); 1901 1902 if (!getDerived().AlwaysRebuild() && 1903 TransTemplate == Template) 1904 return Name; 1905 1906 return TemplateName(TransTemplate); 1907 } 1908 1909 OverloadedFunctionDecl *Ovl = Name.getAsOverloadedFunctionDecl(); 1910 assert(Ovl && "Not a template name or an overload set?"); 1911 OverloadedFunctionDecl *TransOvl 1912 = cast_or_null<OverloadedFunctionDecl>(getDerived().TransformDecl(Ovl)); 1913 if (!TransOvl) 1914 return TemplateName(); 1915 1916 if (!getDerived().AlwaysRebuild() && 1917 TransOvl == Ovl) 1918 return Name; 1919 1920 return TemplateName(TransOvl); 1921} 1922 1923template<typename Derived> 1924void TreeTransform<Derived>::InventTemplateArgumentLoc( 1925 const TemplateArgument &Arg, 1926 TemplateArgumentLoc &Output) { 1927 SourceLocation Loc = getDerived().getBaseLocation(); 1928 switch (Arg.getKind()) { 1929 case TemplateArgument::Null: 1930 llvm::llvm_unreachable("null template argument in TreeTransform"); 1931 break; 1932 1933 case TemplateArgument::Type: 1934 Output = TemplateArgumentLoc(Arg, 1935 SemaRef.Context.getTrivialDeclaratorInfo(Arg.getAsType(), Loc)); 1936 1937 break; 1938 1939 case TemplateArgument::Template: 1940 Output = TemplateArgumentLoc(Arg, SourceRange(), Loc); 1941 break; 1942 1943 case TemplateArgument::Expression: 1944 Output = TemplateArgumentLoc(Arg, Arg.getAsExpr()); 1945 break; 1946 1947 case TemplateArgument::Declaration: 1948 case TemplateArgument::Integral: 1949 case TemplateArgument::Pack: 1950 Output = TemplateArgumentLoc(Arg, TemplateArgumentLocInfo()); 1951 break; 1952 } 1953} 1954 1955template<typename Derived> 1956bool TreeTransform<Derived>::TransformTemplateArgument( 1957 const TemplateArgumentLoc &Input, 1958 TemplateArgumentLoc &Output) { 1959 const TemplateArgument &Arg = Input.getArgument(); 1960 switch (Arg.getKind()) { 1961 case TemplateArgument::Null: 1962 case TemplateArgument::Integral: 1963 Output = Input; 1964 return false; 1965 1966 case TemplateArgument::Type: { 1967 DeclaratorInfo *DI = Input.getSourceDeclaratorInfo(); 1968 if (DI == NULL) 1969 DI = InventDeclaratorInfo(Input.getArgument().getAsType()); 1970 1971 DI = getDerived().TransformType(DI); 1972 if (!DI) return true; 1973 1974 Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI); 1975 return false; 1976 } 1977 1978 case TemplateArgument::Declaration: { 1979 // FIXME: we should never have to transform one of these. 1980 DeclarationName Name; 1981 if (NamedDecl *ND = dyn_cast<NamedDecl>(Arg.getAsDecl())) 1982 Name = ND->getDeclName(); 1983 TemporaryBase Rebase(*this, Input.getLocation(), Name); 1984 Decl *D = getDerived().TransformDecl(Arg.getAsDecl()); 1985 if (!D) return true; 1986 1987 Expr *SourceExpr = Input.getSourceDeclExpression(); 1988 if (SourceExpr) { 1989 EnterExpressionEvaluationContext Unevaluated(getSema(), 1990 Action::Unevaluated); 1991 Sema::OwningExprResult E = getDerived().TransformExpr(SourceExpr); 1992 if (E.isInvalid()) 1993 SourceExpr = NULL; 1994 else { 1995 SourceExpr = E.takeAs<Expr>(); 1996 SourceExpr->Retain(); 1997 } 1998 } 1999 2000 Output = TemplateArgumentLoc(TemplateArgument(D), SourceExpr); 2001 return false; 2002 } 2003 2004 case TemplateArgument::Template: { 2005 TemporaryBase Rebase(*this, Input.getLocation(), DeclarationName()); 2006 TemplateName Template 2007 = getDerived().TransformTemplateName(Arg.getAsTemplate()); 2008 if (Template.isNull()) 2009 return true; 2010 2011 Output = TemplateArgumentLoc(TemplateArgument(Template), 2012 Input.getTemplateQualifierRange(), 2013 Input.getTemplateNameLoc()); 2014 return false; 2015 } 2016 2017 case TemplateArgument::Expression: { 2018 // Template argument expressions are not potentially evaluated. 2019 EnterExpressionEvaluationContext Unevaluated(getSema(), 2020 Action::Unevaluated); 2021 2022 Expr *InputExpr = Input.getSourceExpression(); 2023 if (!InputExpr) InputExpr = Input.getArgument().getAsExpr(); 2024 2025 Sema::OwningExprResult E 2026 = getDerived().TransformExpr(InputExpr); 2027 if (E.isInvalid()) return true; 2028 2029 Expr *ETaken = E.takeAs<Expr>(); 2030 ETaken->Retain(); 2031 Output = TemplateArgumentLoc(TemplateArgument(ETaken), ETaken); 2032 return false; 2033 } 2034 2035 case TemplateArgument::Pack: { 2036 llvm::SmallVector<TemplateArgument, 4> TransformedArgs; 2037 TransformedArgs.reserve(Arg.pack_size()); 2038 for (TemplateArgument::pack_iterator A = Arg.pack_begin(), 2039 AEnd = Arg.pack_end(); 2040 A != AEnd; ++A) { 2041 2042 // FIXME: preserve source information here when we start 2043 // caring about parameter packs. 2044 2045 TemplateArgumentLoc InputArg; 2046 TemplateArgumentLoc OutputArg; 2047 getDerived().InventTemplateArgumentLoc(*A, InputArg); 2048 if (getDerived().TransformTemplateArgument(InputArg, OutputArg)) 2049 return true; 2050 2051 TransformedArgs.push_back(OutputArg.getArgument()); 2052 } 2053 TemplateArgument Result; 2054 Result.setArgumentPack(TransformedArgs.data(), TransformedArgs.size(), 2055 true); 2056 Output = TemplateArgumentLoc(Result, Input.getLocInfo()); 2057 return false; 2058 } 2059 } 2060 2061 // Work around bogus GCC warning 2062 return true; 2063} 2064 2065//===----------------------------------------------------------------------===// 2066// Type transformation 2067//===----------------------------------------------------------------------===// 2068 2069template<typename Derived> 2070QualType TreeTransform<Derived>::TransformType(QualType T) { 2071 if (getDerived().AlreadyTransformed(T)) 2072 return T; 2073 2074 // Temporary workaround. All of these transformations should 2075 // eventually turn into transformations on TypeLocs. 2076 DeclaratorInfo *DI = getSema().Context.CreateDeclaratorInfo(T); 2077 DI->getTypeLoc().initialize(getDerived().getBaseLocation()); 2078 2079 DeclaratorInfo *NewDI = getDerived().TransformType(DI); 2080 2081 if (!NewDI) 2082 return QualType(); 2083 2084 return NewDI->getType(); 2085} 2086 2087template<typename Derived> 2088DeclaratorInfo *TreeTransform<Derived>::TransformType(DeclaratorInfo *DI) { 2089 if (getDerived().AlreadyTransformed(DI->getType())) 2090 return DI; 2091 2092 TypeLocBuilder TLB; 2093 2094 TypeLoc TL = DI->getTypeLoc(); 2095 TLB.reserve(TL.getFullDataSize()); 2096 2097 QualType Result = getDerived().TransformType(TLB, TL); 2098 if (Result.isNull()) 2099 return 0; 2100 2101 return TLB.getDeclaratorInfo(SemaRef.Context, Result); 2102} 2103 2104template<typename Derived> 2105QualType 2106TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T) { 2107 switch (T.getTypeLocClass()) { 2108#define ABSTRACT_TYPELOC(CLASS, PARENT) 2109#define TYPELOC(CLASS, PARENT) \ 2110 case TypeLoc::CLASS: \ 2111 return getDerived().Transform##CLASS##Type(TLB, cast<CLASS##TypeLoc>(T)); 2112#include "clang/AST/TypeLocNodes.def" 2113 } 2114 2115 llvm::llvm_unreachable("unhandled type loc!"); 2116 return QualType(); 2117} 2118 2119/// FIXME: By default, this routine adds type qualifiers only to types 2120/// that can have qualifiers, and silently suppresses those qualifiers 2121/// that are not permitted (e.g., qualifiers on reference or function 2122/// types). This is the right thing for template instantiation, but 2123/// probably not for other clients. 2124template<typename Derived> 2125QualType 2126TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB, 2127 QualifiedTypeLoc T) { 2128 Qualifiers Quals = T.getType().getLocalQualifiers(); 2129 2130 QualType Result = getDerived().TransformType(TLB, T.getUnqualifiedLoc()); 2131 if (Result.isNull()) 2132 return QualType(); 2133 2134 // Silently suppress qualifiers if the result type can't be qualified. 2135 // FIXME: this is the right thing for template instantiation, but 2136 // probably not for other clients. 2137 if (Result->isFunctionType() || Result->isReferenceType()) 2138 return Result; 2139 2140 Result = SemaRef.Context.getQualifiedType(Result, Quals); 2141 2142 TLB.push<QualifiedTypeLoc>(Result); 2143 2144 // No location information to preserve. 2145 2146 return Result; 2147} 2148 2149template <class TyLoc> static inline 2150QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) { 2151 TyLoc NewT = TLB.push<TyLoc>(T.getType()); 2152 NewT.setNameLoc(T.getNameLoc()); 2153 return T.getType(); 2154} 2155 2156// Ugly metaprogramming macros because I couldn't be bothered to make 2157// the equivalent template version work. 2158#define TransformPointerLikeType(TypeClass) do { \ 2159 QualType PointeeType \ 2160 = getDerived().TransformType(TLB, TL.getPointeeLoc()); \ 2161 if (PointeeType.isNull()) \ 2162 return QualType(); \ 2163 \ 2164 QualType Result = TL.getType(); \ 2165 if (getDerived().AlwaysRebuild() || \ 2166 PointeeType != TL.getPointeeLoc().getType()) { \ 2167 Result = getDerived().Rebuild##TypeClass(PointeeType, \ 2168 TL.getSigilLoc()); \ 2169 if (Result.isNull()) \ 2170 return QualType(); \ 2171 } \ 2172 \ 2173 TypeClass##Loc NewT = TLB.push<TypeClass##Loc>(Result); \ 2174 NewT.setSigilLoc(TL.getSigilLoc()); \ 2175 \ 2176 return Result; \ 2177} while(0) 2178 2179template<typename Derived> 2180QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB, 2181 BuiltinTypeLoc T) { 2182 return TransformTypeSpecType(TLB, T); 2183} 2184 2185template<typename Derived> 2186QualType 2187TreeTransform<Derived>::TransformFixedWidthIntType(TypeLocBuilder &TLB, 2188 FixedWidthIntTypeLoc T) { 2189 return TransformTypeSpecType(TLB, T); 2190} 2191 2192template<typename Derived> 2193QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB, 2194 ComplexTypeLoc T) { 2195 // FIXME: recurse? 2196 return TransformTypeSpecType(TLB, T); 2197} 2198 2199template<typename Derived> 2200QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB, 2201 PointerTypeLoc TL) { 2202 TransformPointerLikeType(PointerType); 2203} 2204 2205template<typename Derived> 2206QualType 2207TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB, 2208 BlockPointerTypeLoc TL) { 2209 TransformPointerLikeType(BlockPointerType); 2210} 2211 2212/// Transforms a reference type. Note that somewhat paradoxically we 2213/// don't care whether the type itself is an l-value type or an r-value 2214/// type; we only care if the type was *written* as an l-value type 2215/// or an r-value type. 2216template<typename Derived> 2217QualType 2218TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB, 2219 ReferenceTypeLoc TL) { 2220 const ReferenceType *T = TL.getTypePtr(); 2221 2222 // Note that this works with the pointee-as-written. 2223 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); 2224 if (PointeeType.isNull()) 2225 return QualType(); 2226 2227 QualType Result = TL.getType(); 2228 if (getDerived().AlwaysRebuild() || 2229 PointeeType != T->getPointeeTypeAsWritten()) { 2230 Result = getDerived().RebuildReferenceType(PointeeType, 2231 T->isSpelledAsLValue(), 2232 TL.getSigilLoc()); 2233 if (Result.isNull()) 2234 return QualType(); 2235 } 2236 2237 // r-value references can be rebuilt as l-value references. 2238 ReferenceTypeLoc NewTL; 2239 if (isa<LValueReferenceType>(Result)) 2240 NewTL = TLB.push<LValueReferenceTypeLoc>(Result); 2241 else 2242 NewTL = TLB.push<RValueReferenceTypeLoc>(Result); 2243 NewTL.setSigilLoc(TL.getSigilLoc()); 2244 2245 return Result; 2246} 2247 2248template<typename Derived> 2249QualType 2250TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB, 2251 LValueReferenceTypeLoc TL) { 2252 return TransformReferenceType(TLB, TL); 2253} 2254 2255template<typename Derived> 2256QualType 2257TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB, 2258 RValueReferenceTypeLoc TL) { 2259 return TransformReferenceType(TLB, TL); 2260} 2261 2262template<typename Derived> 2263QualType 2264TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB, 2265 MemberPointerTypeLoc TL) { 2266 MemberPointerType *T = TL.getTypePtr(); 2267 2268 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); 2269 if (PointeeType.isNull()) 2270 return QualType(); 2271 2272 // TODO: preserve source information for this. 2273 QualType ClassType 2274 = getDerived().TransformType(QualType(T->getClass(), 0)); 2275 if (ClassType.isNull()) 2276 return QualType(); 2277 2278 QualType Result = TL.getType(); 2279 if (getDerived().AlwaysRebuild() || 2280 PointeeType != T->getPointeeType() || 2281 ClassType != QualType(T->getClass(), 0)) { 2282 Result = getDerived().RebuildMemberPointerType(PointeeType, ClassType, 2283 TL.getStarLoc()); 2284 if (Result.isNull()) 2285 return QualType(); 2286 } 2287 2288 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result); 2289 NewTL.setSigilLoc(TL.getSigilLoc()); 2290 2291 return Result; 2292} 2293 2294template<typename Derived> 2295QualType 2296TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB, 2297 ConstantArrayTypeLoc TL) { 2298 ConstantArrayType *T = TL.getTypePtr(); 2299 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 2300 if (ElementType.isNull()) 2301 return QualType(); 2302 2303 QualType Result = TL.getType(); 2304 if (getDerived().AlwaysRebuild() || 2305 ElementType != T->getElementType()) { 2306 Result = getDerived().RebuildConstantArrayType(ElementType, 2307 T->getSizeModifier(), 2308 T->getSize(), 2309 T->getIndexTypeCVRQualifiers(), 2310 TL.getBracketsRange()); 2311 if (Result.isNull()) 2312 return QualType(); 2313 } 2314 2315 ConstantArrayTypeLoc NewTL = TLB.push<ConstantArrayTypeLoc>(Result); 2316 NewTL.setLBracketLoc(TL.getLBracketLoc()); 2317 NewTL.setRBracketLoc(TL.getRBracketLoc()); 2318 2319 Expr *Size = TL.getSizeExpr(); 2320 if (Size) { 2321 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2322 Size = getDerived().TransformExpr(Size).template takeAs<Expr>(); 2323 } 2324 NewTL.setSizeExpr(Size); 2325 2326 return Result; 2327} 2328 2329template<typename Derived> 2330QualType TreeTransform<Derived>::TransformIncompleteArrayType( 2331 TypeLocBuilder &TLB, 2332 IncompleteArrayTypeLoc TL) { 2333 IncompleteArrayType *T = TL.getTypePtr(); 2334 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 2335 if (ElementType.isNull()) 2336 return QualType(); 2337 2338 QualType Result = TL.getType(); 2339 if (getDerived().AlwaysRebuild() || 2340 ElementType != T->getElementType()) { 2341 Result = getDerived().RebuildIncompleteArrayType(ElementType, 2342 T->getSizeModifier(), 2343 T->getIndexTypeCVRQualifiers(), 2344 TL.getBracketsRange()); 2345 if (Result.isNull()) 2346 return QualType(); 2347 } 2348 2349 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result); 2350 NewTL.setLBracketLoc(TL.getLBracketLoc()); 2351 NewTL.setRBracketLoc(TL.getRBracketLoc()); 2352 NewTL.setSizeExpr(0); 2353 2354 return Result; 2355} 2356 2357template<typename Derived> 2358QualType 2359TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB, 2360 VariableArrayTypeLoc TL) { 2361 VariableArrayType *T = TL.getTypePtr(); 2362 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 2363 if (ElementType.isNull()) 2364 return QualType(); 2365 2366 // Array bounds are not potentially evaluated contexts 2367 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2368 2369 Sema::OwningExprResult SizeResult 2370 = getDerived().TransformExpr(T->getSizeExpr()); 2371 if (SizeResult.isInvalid()) 2372 return QualType(); 2373 2374 Expr *Size = static_cast<Expr*>(SizeResult.get()); 2375 2376 QualType Result = TL.getType(); 2377 if (getDerived().AlwaysRebuild() || 2378 ElementType != T->getElementType() || 2379 Size != T->getSizeExpr()) { 2380 Result = getDerived().RebuildVariableArrayType(ElementType, 2381 T->getSizeModifier(), 2382 move(SizeResult), 2383 T->getIndexTypeCVRQualifiers(), 2384 TL.getBracketsRange()); 2385 if (Result.isNull()) 2386 return QualType(); 2387 } 2388 else SizeResult.take(); 2389 2390 VariableArrayTypeLoc NewTL = TLB.push<VariableArrayTypeLoc>(Result); 2391 NewTL.setLBracketLoc(TL.getLBracketLoc()); 2392 NewTL.setRBracketLoc(TL.getRBracketLoc()); 2393 NewTL.setSizeExpr(Size); 2394 2395 return Result; 2396} 2397 2398template<typename Derived> 2399QualType 2400TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB, 2401 DependentSizedArrayTypeLoc TL) { 2402 DependentSizedArrayType *T = TL.getTypePtr(); 2403 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 2404 if (ElementType.isNull()) 2405 return QualType(); 2406 2407 // Array bounds are not potentially evaluated contexts 2408 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2409 2410 Sema::OwningExprResult SizeResult 2411 = getDerived().TransformExpr(T->getSizeExpr()); 2412 if (SizeResult.isInvalid()) 2413 return QualType(); 2414 2415 Expr *Size = static_cast<Expr*>(SizeResult.get()); 2416 2417 QualType Result = TL.getType(); 2418 if (getDerived().AlwaysRebuild() || 2419 ElementType != T->getElementType() || 2420 Size != T->getSizeExpr()) { 2421 Result = getDerived().RebuildDependentSizedArrayType(ElementType, 2422 T->getSizeModifier(), 2423 move(SizeResult), 2424 T->getIndexTypeCVRQualifiers(), 2425 TL.getBracketsRange()); 2426 if (Result.isNull()) 2427 return QualType(); 2428 } 2429 else SizeResult.take(); 2430 2431 // We might have any sort of array type now, but fortunately they 2432 // all have the same location layout. 2433 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result); 2434 NewTL.setLBracketLoc(TL.getLBracketLoc()); 2435 NewTL.setRBracketLoc(TL.getRBracketLoc()); 2436 NewTL.setSizeExpr(Size); 2437 2438 return Result; 2439} 2440 2441template<typename Derived> 2442QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType( 2443 TypeLocBuilder &TLB, 2444 DependentSizedExtVectorTypeLoc TL) { 2445 DependentSizedExtVectorType *T = TL.getTypePtr(); 2446 2447 // FIXME: ext vector locs should be nested 2448 QualType ElementType = getDerived().TransformType(T->getElementType()); 2449 if (ElementType.isNull()) 2450 return QualType(); 2451 2452 // Vector sizes are not potentially evaluated contexts 2453 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2454 2455 Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); 2456 if (Size.isInvalid()) 2457 return QualType(); 2458 2459 QualType Result = TL.getType(); 2460 if (getDerived().AlwaysRebuild() || 2461 ElementType != T->getElementType() || 2462 Size.get() != T->getSizeExpr()) { 2463 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType, 2464 move(Size), 2465 T->getAttributeLoc()); 2466 if (Result.isNull()) 2467 return QualType(); 2468 } 2469 else Size.take(); 2470 2471 // Result might be dependent or not. 2472 if (isa<DependentSizedExtVectorType>(Result)) { 2473 DependentSizedExtVectorTypeLoc NewTL 2474 = TLB.push<DependentSizedExtVectorTypeLoc>(Result); 2475 NewTL.setNameLoc(TL.getNameLoc()); 2476 } else { 2477 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); 2478 NewTL.setNameLoc(TL.getNameLoc()); 2479 } 2480 2481 return Result; 2482} 2483 2484template<typename Derived> 2485QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB, 2486 VectorTypeLoc TL) { 2487 VectorType *T = TL.getTypePtr(); 2488 QualType ElementType = getDerived().TransformType(T->getElementType()); 2489 if (ElementType.isNull()) 2490 return QualType(); 2491 2492 QualType Result = TL.getType(); 2493 if (getDerived().AlwaysRebuild() || 2494 ElementType != T->getElementType()) { 2495 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements()); 2496 if (Result.isNull()) 2497 return QualType(); 2498 } 2499 2500 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result); 2501 NewTL.setNameLoc(TL.getNameLoc()); 2502 2503 return Result; 2504} 2505 2506template<typename Derived> 2507QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB, 2508 ExtVectorTypeLoc TL) { 2509 VectorType *T = TL.getTypePtr(); 2510 QualType ElementType = getDerived().TransformType(T->getElementType()); 2511 if (ElementType.isNull()) 2512 return QualType(); 2513 2514 QualType Result = TL.getType(); 2515 if (getDerived().AlwaysRebuild() || 2516 ElementType != T->getElementType()) { 2517 Result = getDerived().RebuildExtVectorType(ElementType, 2518 T->getNumElements(), 2519 /*FIXME*/ SourceLocation()); 2520 if (Result.isNull()) 2521 return QualType(); 2522 } 2523 2524 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); 2525 NewTL.setNameLoc(TL.getNameLoc()); 2526 2527 return Result; 2528} 2529 2530template<typename Derived> 2531QualType 2532TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB, 2533 FunctionProtoTypeLoc TL) { 2534 FunctionProtoType *T = TL.getTypePtr(); 2535 QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 2536 if (ResultType.isNull()) 2537 return QualType(); 2538 2539 // Transform the parameters. 2540 llvm::SmallVector<QualType, 4> ParamTypes; 2541 llvm::SmallVector<ParmVarDecl*, 4> ParamDecls; 2542 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 2543 ParmVarDecl *OldParm = TL.getArg(i); 2544 2545 QualType NewType; 2546 ParmVarDecl *NewParm; 2547 2548 if (OldParm) { 2549 DeclaratorInfo *OldDI = OldParm->getDeclaratorInfo(); 2550 assert(OldDI->getType() == T->getArgType(i)); 2551 2552 DeclaratorInfo *NewDI = getDerived().TransformType(OldDI); 2553 if (!NewDI) 2554 return QualType(); 2555 2556 if (NewDI == OldDI) 2557 NewParm = OldParm; 2558 else 2559 NewParm = ParmVarDecl::Create(SemaRef.Context, 2560 OldParm->getDeclContext(), 2561 OldParm->getLocation(), 2562 OldParm->getIdentifier(), 2563 NewDI->getType(), 2564 NewDI, 2565 OldParm->getStorageClass(), 2566 /* DefArg */ NULL); 2567 NewType = NewParm->getType(); 2568 2569 // Deal with the possibility that we don't have a parameter 2570 // declaration for this parameter. 2571 } else { 2572 NewParm = 0; 2573 2574 QualType OldType = T->getArgType(i); 2575 NewType = getDerived().TransformType(OldType); 2576 if (NewType.isNull()) 2577 return QualType(); 2578 } 2579 2580 ParamTypes.push_back(NewType); 2581 ParamDecls.push_back(NewParm); 2582 } 2583 2584 QualType Result = TL.getType(); 2585 if (getDerived().AlwaysRebuild() || 2586 ResultType != T->getResultType() || 2587 !std::equal(T->arg_type_begin(), T->arg_type_end(), ParamTypes.begin())) { 2588 Result = getDerived().RebuildFunctionProtoType(ResultType, 2589 ParamTypes.data(), 2590 ParamTypes.size(), 2591 T->isVariadic(), 2592 T->getTypeQuals()); 2593 if (Result.isNull()) 2594 return QualType(); 2595 } 2596 2597 FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result); 2598 NewTL.setLParenLoc(TL.getLParenLoc()); 2599 NewTL.setRParenLoc(TL.getRParenLoc()); 2600 for (unsigned i = 0, e = NewTL.getNumArgs(); i != e; ++i) 2601 NewTL.setArg(i, ParamDecls[i]); 2602 2603 return Result; 2604} 2605 2606template<typename Derived> 2607QualType TreeTransform<Derived>::TransformFunctionNoProtoType( 2608 TypeLocBuilder &TLB, 2609 FunctionNoProtoTypeLoc TL) { 2610 FunctionNoProtoType *T = TL.getTypePtr(); 2611 QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 2612 if (ResultType.isNull()) 2613 return QualType(); 2614 2615 QualType Result = TL.getType(); 2616 if (getDerived().AlwaysRebuild() || 2617 ResultType != T->getResultType()) 2618 Result = getDerived().RebuildFunctionNoProtoType(ResultType); 2619 2620 FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result); 2621 NewTL.setLParenLoc(TL.getLParenLoc()); 2622 NewTL.setRParenLoc(TL.getRParenLoc()); 2623 2624 return Result; 2625} 2626 2627template<typename Derived> 2628QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB, 2629 TypedefTypeLoc TL) { 2630 TypedefType *T = TL.getTypePtr(); 2631 TypedefDecl *Typedef 2632 = cast_or_null<TypedefDecl>(getDerived().TransformDecl(T->getDecl())); 2633 if (!Typedef) 2634 return QualType(); 2635 2636 QualType Result = TL.getType(); 2637 if (getDerived().AlwaysRebuild() || 2638 Typedef != T->getDecl()) { 2639 Result = getDerived().RebuildTypedefType(Typedef); 2640 if (Result.isNull()) 2641 return QualType(); 2642 } 2643 2644 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result); 2645 NewTL.setNameLoc(TL.getNameLoc()); 2646 2647 return Result; 2648} 2649 2650template<typename Derived> 2651QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB, 2652 TypeOfExprTypeLoc TL) { 2653 TypeOfExprType *T = TL.getTypePtr(); 2654 2655 // typeof expressions are not potentially evaluated contexts 2656 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2657 2658 Sema::OwningExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); 2659 if (E.isInvalid()) 2660 return QualType(); 2661 2662 QualType Result = TL.getType(); 2663 if (getDerived().AlwaysRebuild() || 2664 E.get() != T->getUnderlyingExpr()) { 2665 Result = getDerived().RebuildTypeOfExprType(move(E)); 2666 if (Result.isNull()) 2667 return QualType(); 2668 } 2669 else E.take(); 2670 2671 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result); 2672 NewTL.setNameLoc(TL.getNameLoc()); 2673 2674 return Result; 2675} 2676 2677template<typename Derived> 2678QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB, 2679 TypeOfTypeLoc TL) { 2680 TypeOfType *T = TL.getTypePtr(); 2681 2682 // FIXME: should be an inner type, or at least have a DeclaratorInfo. 2683 QualType Underlying = getDerived().TransformType(T->getUnderlyingType()); 2684 if (Underlying.isNull()) 2685 return QualType(); 2686 2687 QualType Result = TL.getType(); 2688 if (getDerived().AlwaysRebuild() || 2689 Underlying != T->getUnderlyingType()) { 2690 Result = getDerived().RebuildTypeOfType(Underlying); 2691 if (Result.isNull()) 2692 return QualType(); 2693 } 2694 2695 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result); 2696 NewTL.setNameLoc(TL.getNameLoc()); 2697 2698 return Result; 2699} 2700 2701template<typename Derived> 2702QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB, 2703 DecltypeTypeLoc TL) { 2704 DecltypeType *T = TL.getTypePtr(); 2705 2706 // decltype expressions are not potentially evaluated contexts 2707 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2708 2709 Sema::OwningExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); 2710 if (E.isInvalid()) 2711 return QualType(); 2712 2713 QualType Result = TL.getType(); 2714 if (getDerived().AlwaysRebuild() || 2715 E.get() != T->getUnderlyingExpr()) { 2716 Result = getDerived().RebuildDecltypeType(move(E)); 2717 if (Result.isNull()) 2718 return QualType(); 2719 } 2720 else E.take(); 2721 2722 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result); 2723 NewTL.setNameLoc(TL.getNameLoc()); 2724 2725 return Result; 2726} 2727 2728template<typename Derived> 2729QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB, 2730 RecordTypeLoc TL) { 2731 RecordType *T = TL.getTypePtr(); 2732 RecordDecl *Record 2733 = cast_or_null<RecordDecl>(getDerived().TransformDecl(T->getDecl())); 2734 if (!Record) 2735 return QualType(); 2736 2737 QualType Result = TL.getType(); 2738 if (getDerived().AlwaysRebuild() || 2739 Record != T->getDecl()) { 2740 Result = getDerived().RebuildRecordType(Record); 2741 if (Result.isNull()) 2742 return QualType(); 2743 } 2744 2745 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result); 2746 NewTL.setNameLoc(TL.getNameLoc()); 2747 2748 return Result; 2749} 2750 2751template<typename Derived> 2752QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB, 2753 EnumTypeLoc TL) { 2754 EnumType *T = TL.getTypePtr(); 2755 EnumDecl *Enum 2756 = cast_or_null<EnumDecl>(getDerived().TransformDecl(T->getDecl())); 2757 if (!Enum) 2758 return QualType(); 2759 2760 QualType Result = TL.getType(); 2761 if (getDerived().AlwaysRebuild() || 2762 Enum != T->getDecl()) { 2763 Result = getDerived().RebuildEnumType(Enum); 2764 if (Result.isNull()) 2765 return QualType(); 2766 } 2767 2768 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result); 2769 NewTL.setNameLoc(TL.getNameLoc()); 2770 2771 return Result; 2772} 2773 2774template <typename Derived> 2775QualType TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB, 2776 ElaboratedTypeLoc TL) { 2777 ElaboratedType *T = TL.getTypePtr(); 2778 2779 // FIXME: this should be a nested type. 2780 QualType Underlying = getDerived().TransformType(T->getUnderlyingType()); 2781 if (Underlying.isNull()) 2782 return QualType(); 2783 2784 QualType Result = TL.getType(); 2785 if (getDerived().AlwaysRebuild() || 2786 Underlying != T->getUnderlyingType()) { 2787 Result = getDerived().RebuildElaboratedType(Underlying, T->getTagKind()); 2788 if (Result.isNull()) 2789 return QualType(); 2790 } 2791 2792 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 2793 NewTL.setNameLoc(TL.getNameLoc()); 2794 2795 return Result; 2796} 2797 2798 2799template<typename Derived> 2800QualType TreeTransform<Derived>::TransformTemplateTypeParmType( 2801 TypeLocBuilder &TLB, 2802 TemplateTypeParmTypeLoc TL) { 2803 return TransformTypeSpecType(TLB, TL); 2804} 2805 2806template<typename Derived> 2807QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType( 2808 TypeLocBuilder &TLB, 2809 SubstTemplateTypeParmTypeLoc TL) { 2810 return TransformTypeSpecType(TLB, TL); 2811} 2812 2813template<typename Derived> 2814inline QualType 2815TreeTransform<Derived>::TransformTemplateSpecializationType( 2816 TypeLocBuilder &TLB, 2817 TemplateSpecializationTypeLoc TL) { 2818 return TransformTemplateSpecializationType(TLB, TL, QualType()); 2819} 2820 2821template<typename Derived> 2822QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 2823 const TemplateSpecializationType *TST, 2824 QualType ObjectType) { 2825 // FIXME: this entire method is a temporary workaround; callers 2826 // should be rewritten to provide real type locs. 2827 2828 // Fake up a TemplateSpecializationTypeLoc. 2829 TypeLocBuilder TLB; 2830 TemplateSpecializationTypeLoc TL 2831 = TLB.push<TemplateSpecializationTypeLoc>(QualType(TST, 0)); 2832 2833 SourceLocation BaseLoc = getDerived().getBaseLocation(); 2834 2835 TL.setTemplateNameLoc(BaseLoc); 2836 TL.setLAngleLoc(BaseLoc); 2837 TL.setRAngleLoc(BaseLoc); 2838 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 2839 const TemplateArgument &TA = TST->getArg(i); 2840 TemplateArgumentLoc TAL; 2841 getDerived().InventTemplateArgumentLoc(TA, TAL); 2842 TL.setArgLocInfo(i, TAL.getLocInfo()); 2843 } 2844 2845 TypeLocBuilder IgnoredTLB; 2846 return TransformTemplateSpecializationType(IgnoredTLB, TL, ObjectType); 2847} 2848 2849template<typename Derived> 2850QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 2851 TypeLocBuilder &TLB, 2852 TemplateSpecializationTypeLoc TL, 2853 QualType ObjectType) { 2854 const TemplateSpecializationType *T = TL.getTypePtr(); 2855 2856 TemplateName Template 2857 = getDerived().TransformTemplateName(T->getTemplateName(), ObjectType); 2858 if (Template.isNull()) 2859 return QualType(); 2860 2861 TemplateArgumentListInfo NewTemplateArgs; 2862 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 2863 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 2864 2865 for (unsigned i = 0, e = T->getNumArgs(); i != e; ++i) { 2866 TemplateArgumentLoc Loc; 2867 if (getDerived().TransformTemplateArgument(TL.getArgLoc(i), Loc)) 2868 return QualType(); 2869 NewTemplateArgs.addArgument(Loc); 2870 } 2871 2872 // FIXME: maybe don't rebuild if all the template arguments are the same. 2873 2874 QualType Result = 2875 getDerived().RebuildTemplateSpecializationType(Template, 2876 TL.getTemplateNameLoc(), 2877 NewTemplateArgs); 2878 2879 if (!Result.isNull()) { 2880 TemplateSpecializationTypeLoc NewTL 2881 = TLB.push<TemplateSpecializationTypeLoc>(Result); 2882 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 2883 NewTL.setLAngleLoc(TL.getLAngleLoc()); 2884 NewTL.setRAngleLoc(TL.getRAngleLoc()); 2885 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 2886 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 2887 } 2888 2889 return Result; 2890} 2891 2892template<typename Derived> 2893QualType 2894TreeTransform<Derived>::TransformQualifiedNameType(TypeLocBuilder &TLB, 2895 QualifiedNameTypeLoc TL) { 2896 QualifiedNameType *T = TL.getTypePtr(); 2897 NestedNameSpecifier *NNS 2898 = getDerived().TransformNestedNameSpecifier(T->getQualifier(), 2899 SourceRange()); 2900 if (!NNS) 2901 return QualType(); 2902 2903 QualType Named = getDerived().TransformType(T->getNamedType()); 2904 if (Named.isNull()) 2905 return QualType(); 2906 2907 QualType Result = TL.getType(); 2908 if (getDerived().AlwaysRebuild() || 2909 NNS != T->getQualifier() || 2910 Named != T->getNamedType()) { 2911 Result = getDerived().RebuildQualifiedNameType(NNS, Named); 2912 if (Result.isNull()) 2913 return QualType(); 2914 } 2915 2916 QualifiedNameTypeLoc NewTL = TLB.push<QualifiedNameTypeLoc>(Result); 2917 NewTL.setNameLoc(TL.getNameLoc()); 2918 2919 return Result; 2920} 2921 2922template<typename Derived> 2923QualType TreeTransform<Derived>::TransformTypenameType(TypeLocBuilder &TLB, 2924 TypenameTypeLoc TL) { 2925 TypenameType *T = TL.getTypePtr(); 2926 2927 /* FIXME: preserve source information better than this */ 2928 SourceRange SR(TL.getNameLoc()); 2929 2930 NestedNameSpecifier *NNS 2931 = getDerived().TransformNestedNameSpecifier(T->getQualifier(), SR); 2932 if (!NNS) 2933 return QualType(); 2934 2935 QualType Result; 2936 2937 if (const TemplateSpecializationType *TemplateId = T->getTemplateId()) { 2938 QualType NewTemplateId 2939 = getDerived().TransformType(QualType(TemplateId, 0)); 2940 if (NewTemplateId.isNull()) 2941 return QualType(); 2942 2943 if (!getDerived().AlwaysRebuild() && 2944 NNS == T->getQualifier() && 2945 NewTemplateId == QualType(TemplateId, 0)) 2946 return QualType(T, 0); 2947 2948 Result = getDerived().RebuildTypenameType(NNS, NewTemplateId); 2949 } else { 2950 Result = getDerived().RebuildTypenameType(NNS, T->getIdentifier(), SR); 2951 } 2952 if (Result.isNull()) 2953 return QualType(); 2954 2955 TypenameTypeLoc NewTL = TLB.push<TypenameTypeLoc>(Result); 2956 NewTL.setNameLoc(TL.getNameLoc()); 2957 2958 return Result; 2959} 2960 2961template<typename Derived> 2962QualType 2963TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB, 2964 ObjCInterfaceTypeLoc TL) { 2965 assert(false && "TransformObjCInterfaceType unimplemented"); 2966 return QualType(); 2967} 2968 2969template<typename Derived> 2970QualType 2971TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB, 2972 ObjCObjectPointerTypeLoc TL) { 2973 assert(false && "TransformObjCObjectPointerType unimplemented"); 2974 return QualType(); 2975} 2976 2977//===----------------------------------------------------------------------===// 2978// Statement transformation 2979//===----------------------------------------------------------------------===// 2980template<typename Derived> 2981Sema::OwningStmtResult 2982TreeTransform<Derived>::TransformNullStmt(NullStmt *S) { 2983 return SemaRef.Owned(S->Retain()); 2984} 2985 2986template<typename Derived> 2987Sema::OwningStmtResult 2988TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) { 2989 return getDerived().TransformCompoundStmt(S, false); 2990} 2991 2992template<typename Derived> 2993Sema::OwningStmtResult 2994TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S, 2995 bool IsStmtExpr) { 2996 bool SubStmtChanged = false; 2997 ASTOwningVector<&ActionBase::DeleteStmt> Statements(getSema()); 2998 for (CompoundStmt::body_iterator B = S->body_begin(), BEnd = S->body_end(); 2999 B != BEnd; ++B) { 3000 OwningStmtResult Result = getDerived().TransformStmt(*B); 3001 if (Result.isInvalid()) 3002 return getSema().StmtError(); 3003 3004 SubStmtChanged = SubStmtChanged || Result.get() != *B; 3005 Statements.push_back(Result.takeAs<Stmt>()); 3006 } 3007 3008 if (!getDerived().AlwaysRebuild() && 3009 !SubStmtChanged) 3010 return SemaRef.Owned(S->Retain()); 3011 3012 return getDerived().RebuildCompoundStmt(S->getLBracLoc(), 3013 move_arg(Statements), 3014 S->getRBracLoc(), 3015 IsStmtExpr); 3016} 3017 3018template<typename Derived> 3019Sema::OwningStmtResult 3020TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) { 3021 OwningExprResult LHS(SemaRef), RHS(SemaRef); 3022 { 3023 // The case value expressions are not potentially evaluated. 3024 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 3025 3026 // Transform the left-hand case value. 3027 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 RHS = getDerived().TransformExpr(S->getRHS()); 3033 if (RHS.isInvalid()) 3034 return SemaRef.StmtError(); 3035 } 3036 3037 // Build the case statement. 3038 // Case statements are always rebuilt so that they will attached to their 3039 // transformed switch statement. 3040 OwningStmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(), 3041 move(LHS), 3042 S->getEllipsisLoc(), 3043 move(RHS), 3044 S->getColonLoc()); 3045 if (Case.isInvalid()) 3046 return SemaRef.StmtError(); 3047 3048 // Transform the statement following the case 3049 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 3050 if (SubStmt.isInvalid()) 3051 return SemaRef.StmtError(); 3052 3053 // Attach the body to the case statement 3054 return getDerived().RebuildCaseStmtBody(move(Case), move(SubStmt)); 3055} 3056 3057template<typename Derived> 3058Sema::OwningStmtResult 3059TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) { 3060 // Transform the statement following the default case 3061 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 3062 if (SubStmt.isInvalid()) 3063 return SemaRef.StmtError(); 3064 3065 // Default statements are always rebuilt 3066 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(), 3067 move(SubStmt)); 3068} 3069 3070template<typename Derived> 3071Sema::OwningStmtResult 3072TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) { 3073 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 3074 if (SubStmt.isInvalid()) 3075 return SemaRef.StmtError(); 3076 3077 // FIXME: Pass the real colon location in. 3078 SourceLocation ColonLoc = SemaRef.PP.getLocForEndOfToken(S->getIdentLoc()); 3079 return getDerived().RebuildLabelStmt(S->getIdentLoc(), S->getID(), ColonLoc, 3080 move(SubStmt)); 3081} 3082 3083template<typename Derived> 3084Sema::OwningStmtResult 3085TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { 3086 // Transform the condition 3087 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 3088 if (Cond.isInvalid()) 3089 return SemaRef.StmtError(); 3090 3091 Sema::FullExprArg FullCond(getSema().FullExpr(Cond)); 3092 3093 // Transform the "then" branch. 3094 OwningStmtResult Then = getDerived().TransformStmt(S->getThen()); 3095 if (Then.isInvalid()) 3096 return SemaRef.StmtError(); 3097 3098 // Transform the "else" branch. 3099 OwningStmtResult Else = getDerived().TransformStmt(S->getElse()); 3100 if (Else.isInvalid()) 3101 return SemaRef.StmtError(); 3102 3103 if (!getDerived().AlwaysRebuild() && 3104 FullCond->get() == S->getCond() && 3105 Then.get() == S->getThen() && 3106 Else.get() == S->getElse()) 3107 return SemaRef.Owned(S->Retain()); 3108 3109 return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, move(Then), 3110 S->getElseLoc(), move(Else)); 3111} 3112 3113template<typename Derived> 3114Sema::OwningStmtResult 3115TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) { 3116 // Transform the condition. 3117 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 3118 if (Cond.isInvalid()) 3119 return SemaRef.StmtError(); 3120 3121 // Rebuild the switch statement. 3122 OwningStmtResult Switch = getDerived().RebuildSwitchStmtStart(move(Cond)); 3123 if (Switch.isInvalid()) 3124 return SemaRef.StmtError(); 3125 3126 // Transform the body of the switch statement. 3127 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3128 if (Body.isInvalid()) 3129 return SemaRef.StmtError(); 3130 3131 // Complete the switch statement. 3132 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), move(Switch), 3133 move(Body)); 3134} 3135 3136template<typename Derived> 3137Sema::OwningStmtResult 3138TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) { 3139 // Transform the condition 3140 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 3141 if (Cond.isInvalid()) 3142 return SemaRef.StmtError(); 3143 3144 Sema::FullExprArg FullCond(getSema().FullExpr(Cond)); 3145 3146 // Transform the body 3147 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3148 if (Body.isInvalid()) 3149 return SemaRef.StmtError(); 3150 3151 if (!getDerived().AlwaysRebuild() && 3152 FullCond->get() == S->getCond() && 3153 Body.get() == S->getBody()) 3154 return SemaRef.Owned(S->Retain()); 3155 3156 return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond, move(Body)); 3157} 3158 3159template<typename Derived> 3160Sema::OwningStmtResult 3161TreeTransform<Derived>::TransformDoStmt(DoStmt *S) { 3162 // Transform the condition 3163 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 3164 if (Cond.isInvalid()) 3165 return SemaRef.StmtError(); 3166 3167 // Transform the body 3168 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3169 if (Body.isInvalid()) 3170 return SemaRef.StmtError(); 3171 3172 if (!getDerived().AlwaysRebuild() && 3173 Cond.get() == S->getCond() && 3174 Body.get() == S->getBody()) 3175 return SemaRef.Owned(S->Retain()); 3176 3177 return getDerived().RebuildDoStmt(S->getDoLoc(), move(Body), S->getWhileLoc(), 3178 /*FIXME:*/S->getWhileLoc(), move(Cond), 3179 S->getRParenLoc()); 3180} 3181 3182template<typename Derived> 3183Sema::OwningStmtResult 3184TreeTransform<Derived>::TransformForStmt(ForStmt *S) { 3185 // Transform the initialization statement 3186 OwningStmtResult Init = getDerived().TransformStmt(S->getInit()); 3187 if (Init.isInvalid()) 3188 return SemaRef.StmtError(); 3189 3190 // Transform the condition 3191 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 3192 if (Cond.isInvalid()) 3193 return SemaRef.StmtError(); 3194 3195 // Transform the increment 3196 OwningExprResult Inc = getDerived().TransformExpr(S->getInc()); 3197 if (Inc.isInvalid()) 3198 return SemaRef.StmtError(); 3199 3200 // Transform the body 3201 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3202 if (Body.isInvalid()) 3203 return SemaRef.StmtError(); 3204 3205 if (!getDerived().AlwaysRebuild() && 3206 Init.get() == S->getInit() && 3207 Cond.get() == S->getCond() && 3208 Inc.get() == S->getInc() && 3209 Body.get() == S->getBody()) 3210 return SemaRef.Owned(S->Retain()); 3211 3212 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(), 3213 move(Init), move(Cond), move(Inc), 3214 S->getRParenLoc(), move(Body)); 3215} 3216 3217template<typename Derived> 3218Sema::OwningStmtResult 3219TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) { 3220 // Goto statements must always be rebuilt, to resolve the label. 3221 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(), 3222 S->getLabel()); 3223} 3224 3225template<typename Derived> 3226Sema::OwningStmtResult 3227TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) { 3228 OwningExprResult Target = getDerived().TransformExpr(S->getTarget()); 3229 if (Target.isInvalid()) 3230 return SemaRef.StmtError(); 3231 3232 if (!getDerived().AlwaysRebuild() && 3233 Target.get() == S->getTarget()) 3234 return SemaRef.Owned(S->Retain()); 3235 3236 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(), 3237 move(Target)); 3238} 3239 3240template<typename Derived> 3241Sema::OwningStmtResult 3242TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) { 3243 return SemaRef.Owned(S->Retain()); 3244} 3245 3246template<typename Derived> 3247Sema::OwningStmtResult 3248TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) { 3249 return SemaRef.Owned(S->Retain()); 3250} 3251 3252template<typename Derived> 3253Sema::OwningStmtResult 3254TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) { 3255 Sema::OwningExprResult Result = getDerived().TransformExpr(S->getRetValue()); 3256 if (Result.isInvalid()) 3257 return SemaRef.StmtError(); 3258 3259 // FIXME: We always rebuild the return statement because there is no way 3260 // to tell whether the return type of the function has changed. 3261 return getDerived().RebuildReturnStmt(S->getReturnLoc(), move(Result)); 3262} 3263 3264template<typename Derived> 3265Sema::OwningStmtResult 3266TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) { 3267 bool DeclChanged = false; 3268 llvm::SmallVector<Decl *, 4> Decls; 3269 for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end(); 3270 D != DEnd; ++D) { 3271 Decl *Transformed = getDerived().TransformDefinition(*D); 3272 if (!Transformed) 3273 return SemaRef.StmtError(); 3274 3275 if (Transformed != *D) 3276 DeclChanged = true; 3277 3278 Decls.push_back(Transformed); 3279 } 3280 3281 if (!getDerived().AlwaysRebuild() && !DeclChanged) 3282 return SemaRef.Owned(S->Retain()); 3283 3284 return getDerived().RebuildDeclStmt(Decls.data(), Decls.size(), 3285 S->getStartLoc(), S->getEndLoc()); 3286} 3287 3288template<typename Derived> 3289Sema::OwningStmtResult 3290TreeTransform<Derived>::TransformSwitchCase(SwitchCase *S) { 3291 assert(false && "SwitchCase is abstract and cannot be transformed"); 3292 return SemaRef.Owned(S->Retain()); 3293} 3294 3295template<typename Derived> 3296Sema::OwningStmtResult 3297TreeTransform<Derived>::TransformAsmStmt(AsmStmt *S) { 3298 // FIXME: Implement! 3299 assert(false && "Inline assembly cannot be transformed"); 3300 return SemaRef.Owned(S->Retain()); 3301} 3302 3303 3304template<typename Derived> 3305Sema::OwningStmtResult 3306TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) { 3307 // FIXME: Implement this 3308 assert(false && "Cannot transform an Objective-C @try statement"); 3309 return SemaRef.Owned(S->Retain()); 3310} 3311 3312template<typename Derived> 3313Sema::OwningStmtResult 3314TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) { 3315 // FIXME: Implement this 3316 assert(false && "Cannot transform an Objective-C @catch statement"); 3317 return SemaRef.Owned(S->Retain()); 3318} 3319 3320template<typename Derived> 3321Sema::OwningStmtResult 3322TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 3323 // FIXME: Implement this 3324 assert(false && "Cannot transform an Objective-C @finally statement"); 3325 return SemaRef.Owned(S->Retain()); 3326} 3327 3328template<typename Derived> 3329Sema::OwningStmtResult 3330TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) { 3331 // FIXME: Implement this 3332 assert(false && "Cannot transform an Objective-C @throw statement"); 3333 return SemaRef.Owned(S->Retain()); 3334} 3335 3336template<typename Derived> 3337Sema::OwningStmtResult 3338TreeTransform<Derived>::TransformObjCAtSynchronizedStmt( 3339 ObjCAtSynchronizedStmt *S) { 3340 // FIXME: Implement this 3341 assert(false && "Cannot transform an Objective-C @synchronized statement"); 3342 return SemaRef.Owned(S->Retain()); 3343} 3344 3345template<typename Derived> 3346Sema::OwningStmtResult 3347TreeTransform<Derived>::TransformObjCForCollectionStmt( 3348 ObjCForCollectionStmt *S) { 3349 // FIXME: Implement this 3350 assert(false && "Cannot transform an Objective-C for-each statement"); 3351 return SemaRef.Owned(S->Retain()); 3352} 3353 3354 3355template<typename Derived> 3356Sema::OwningStmtResult 3357TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) { 3358 // Transform the exception declaration, if any. 3359 VarDecl *Var = 0; 3360 if (S->getExceptionDecl()) { 3361 VarDecl *ExceptionDecl = S->getExceptionDecl(); 3362 TemporaryBase Rebase(*this, ExceptionDecl->getLocation(), 3363 ExceptionDecl->getDeclName()); 3364 3365 QualType T = getDerived().TransformType(ExceptionDecl->getType()); 3366 if (T.isNull()) 3367 return SemaRef.StmtError(); 3368 3369 Var = getDerived().RebuildExceptionDecl(ExceptionDecl, 3370 T, 3371 ExceptionDecl->getDeclaratorInfo(), 3372 ExceptionDecl->getIdentifier(), 3373 ExceptionDecl->getLocation(), 3374 /*FIXME: Inaccurate*/ 3375 SourceRange(ExceptionDecl->getLocation())); 3376 if (!Var || Var->isInvalidDecl()) { 3377 if (Var) 3378 Var->Destroy(SemaRef.Context); 3379 return SemaRef.StmtError(); 3380 } 3381 } 3382 3383 // Transform the actual exception handler. 3384 OwningStmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock()); 3385 if (Handler.isInvalid()) { 3386 if (Var) 3387 Var->Destroy(SemaRef.Context); 3388 return SemaRef.StmtError(); 3389 } 3390 3391 if (!getDerived().AlwaysRebuild() && 3392 !Var && 3393 Handler.get() == S->getHandlerBlock()) 3394 return SemaRef.Owned(S->Retain()); 3395 3396 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), 3397 Var, 3398 move(Handler)); 3399} 3400 3401template<typename Derived> 3402Sema::OwningStmtResult 3403TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) { 3404 // Transform the try block itself. 3405 OwningStmtResult TryBlock 3406 = getDerived().TransformCompoundStmt(S->getTryBlock()); 3407 if (TryBlock.isInvalid()) 3408 return SemaRef.StmtError(); 3409 3410 // Transform the handlers. 3411 bool HandlerChanged = false; 3412 ASTOwningVector<&ActionBase::DeleteStmt> Handlers(SemaRef); 3413 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) { 3414 OwningStmtResult Handler 3415 = getDerived().TransformCXXCatchStmt(S->getHandler(I)); 3416 if (Handler.isInvalid()) 3417 return SemaRef.StmtError(); 3418 3419 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I); 3420 Handlers.push_back(Handler.takeAs<Stmt>()); 3421 } 3422 3423 if (!getDerived().AlwaysRebuild() && 3424 TryBlock.get() == S->getTryBlock() && 3425 !HandlerChanged) 3426 return SemaRef.Owned(S->Retain()); 3427 3428 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), move(TryBlock), 3429 move_arg(Handlers)); 3430} 3431 3432//===----------------------------------------------------------------------===// 3433// Expression transformation 3434//===----------------------------------------------------------------------===// 3435template<typename Derived> 3436Sema::OwningExprResult 3437TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E, 3438 bool isAddressOfOperand) { 3439 return SemaRef.Owned(E->Retain()); 3440} 3441 3442template<typename Derived> 3443Sema::OwningExprResult 3444TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E, 3445 bool isAddressOfOperand) { 3446 NestedNameSpecifier *Qualifier = 0; 3447 if (E->getQualifier()) { 3448 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 3449 E->getQualifierRange()); 3450 if (!Qualifier) 3451 return SemaRef.ExprError(); 3452 } 3453 3454 NamedDecl *ND 3455 = dyn_cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getDecl())); 3456 if (!ND) 3457 return SemaRef.ExprError(); 3458 3459 if (!getDerived().AlwaysRebuild() && 3460 Qualifier == E->getQualifier() && 3461 ND == E->getDecl() && 3462 !E->hasExplicitTemplateArgumentList()) 3463 return SemaRef.Owned(E->Retain()); 3464 3465 // FIXME: We're losing the explicit template arguments in this transformation. 3466 3467 llvm::SmallVector<TemplateArgumentLoc, 4> TransArgs(E->getNumTemplateArgs()); 3468 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 3469 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], 3470 TransArgs[I])) 3471 return SemaRef.ExprError(); 3472 } 3473 3474 // FIXME: Pass the qualifier/qualifier range along. 3475 return getDerived().RebuildDeclRefExpr(Qualifier, E->getQualifierRange(), 3476 ND, E->getLocation(), 3477 isAddressOfOperand); 3478} 3479 3480template<typename Derived> 3481Sema::OwningExprResult 3482TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E, 3483 bool isAddressOfOperand) { 3484 return SemaRef.Owned(E->Retain()); 3485} 3486 3487template<typename Derived> 3488Sema::OwningExprResult 3489TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E, 3490 bool isAddressOfOperand) { 3491 return SemaRef.Owned(E->Retain()); 3492} 3493 3494template<typename Derived> 3495Sema::OwningExprResult 3496TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E, 3497 bool isAddressOfOperand) { 3498 return SemaRef.Owned(E->Retain()); 3499} 3500 3501template<typename Derived> 3502Sema::OwningExprResult 3503TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E, 3504 bool isAddressOfOperand) { 3505 return SemaRef.Owned(E->Retain()); 3506} 3507 3508template<typename Derived> 3509Sema::OwningExprResult 3510TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E, 3511 bool isAddressOfOperand) { 3512 return SemaRef.Owned(E->Retain()); 3513} 3514 3515template<typename Derived> 3516Sema::OwningExprResult 3517TreeTransform<Derived>::TransformParenExpr(ParenExpr *E, 3518 bool isAddressOfOperand) { 3519 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 3520 if (SubExpr.isInvalid()) 3521 return SemaRef.ExprError(); 3522 3523 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 3524 return SemaRef.Owned(E->Retain()); 3525 3526 return getDerived().RebuildParenExpr(move(SubExpr), E->getLParen(), 3527 E->getRParen()); 3528} 3529 3530template<typename Derived> 3531Sema::OwningExprResult 3532TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E, 3533 bool isAddressOfOperand) { 3534 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr(), 3535 E->getOpcode() == UnaryOperator::AddrOf); 3536 if (SubExpr.isInvalid()) 3537 return SemaRef.ExprError(); 3538 3539 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 3540 return SemaRef.Owned(E->Retain()); 3541 3542 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(), 3543 E->getOpcode(), 3544 move(SubExpr)); 3545} 3546 3547template<typename Derived> 3548Sema::OwningExprResult 3549TreeTransform<Derived>::TransformSizeOfAlignOfExpr(SizeOfAlignOfExpr *E, 3550 bool isAddressOfOperand) { 3551 if (E->isArgumentType()) { 3552 DeclaratorInfo *OldT = E->getArgumentTypeInfo(); 3553 3554 DeclaratorInfo *NewT = getDerived().TransformType(OldT); 3555 if (!NewT) 3556 return SemaRef.ExprError(); 3557 3558 if (!getDerived().AlwaysRebuild() && OldT == NewT) 3559 return SemaRef.Owned(E->Retain()); 3560 3561 return getDerived().RebuildSizeOfAlignOf(NewT, E->getOperatorLoc(), 3562 E->isSizeOf(), 3563 E->getSourceRange()); 3564 } 3565 3566 Sema::OwningExprResult SubExpr(SemaRef); 3567 { 3568 // C++0x [expr.sizeof]p1: 3569 // The operand is either an expression, which is an unevaluated operand 3570 // [...] 3571 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 3572 3573 SubExpr = getDerived().TransformExpr(E->getArgumentExpr()); 3574 if (SubExpr.isInvalid()) 3575 return SemaRef.ExprError(); 3576 3577 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr()) 3578 return SemaRef.Owned(E->Retain()); 3579 } 3580 3581 return getDerived().RebuildSizeOfAlignOf(move(SubExpr), E->getOperatorLoc(), 3582 E->isSizeOf(), 3583 E->getSourceRange()); 3584} 3585 3586template<typename Derived> 3587Sema::OwningExprResult 3588TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E, 3589 bool isAddressOfOperand) { 3590 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 3591 if (LHS.isInvalid()) 3592 return SemaRef.ExprError(); 3593 3594 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 3595 if (RHS.isInvalid()) 3596 return SemaRef.ExprError(); 3597 3598 3599 if (!getDerived().AlwaysRebuild() && 3600 LHS.get() == E->getLHS() && 3601 RHS.get() == E->getRHS()) 3602 return SemaRef.Owned(E->Retain()); 3603 3604 return getDerived().RebuildArraySubscriptExpr(move(LHS), 3605 /*FIXME:*/E->getLHS()->getLocStart(), 3606 move(RHS), 3607 E->getRBracketLoc()); 3608} 3609 3610template<typename Derived> 3611Sema::OwningExprResult 3612TreeTransform<Derived>::TransformCallExpr(CallExpr *E, 3613 bool isAddressOfOperand) { 3614 // Transform the callee. 3615 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee()); 3616 if (Callee.isInvalid()) 3617 return SemaRef.ExprError(); 3618 3619 // Transform arguments. 3620 bool ArgChanged = false; 3621 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 3622 llvm::SmallVector<SourceLocation, 4> FakeCommaLocs; 3623 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) { 3624 OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I)); 3625 if (Arg.isInvalid()) 3626 return SemaRef.ExprError(); 3627 3628 // FIXME: Wrong source location information for the ','. 3629 FakeCommaLocs.push_back( 3630 SemaRef.PP.getLocForEndOfToken(E->getArg(I)->getSourceRange().getEnd())); 3631 3632 ArgChanged = ArgChanged || Arg.get() != E->getArg(I); 3633 Args.push_back(Arg.takeAs<Expr>()); 3634 } 3635 3636 if (!getDerived().AlwaysRebuild() && 3637 Callee.get() == E->getCallee() && 3638 !ArgChanged) 3639 return SemaRef.Owned(E->Retain()); 3640 3641 // FIXME: Wrong source location information for the '('. 3642 SourceLocation FakeLParenLoc 3643 = ((Expr *)Callee.get())->getSourceRange().getBegin(); 3644 return getDerived().RebuildCallExpr(move(Callee), FakeLParenLoc, 3645 move_arg(Args), 3646 FakeCommaLocs.data(), 3647 E->getRParenLoc()); 3648} 3649 3650template<typename Derived> 3651Sema::OwningExprResult 3652TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E, 3653 bool isAddressOfOperand) { 3654 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 3655 if (Base.isInvalid()) 3656 return SemaRef.ExprError(); 3657 3658 NestedNameSpecifier *Qualifier = 0; 3659 if (E->hasQualifier()) { 3660 Qualifier 3661 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 3662 E->getQualifierRange()); 3663 if (Qualifier == 0) 3664 return SemaRef.ExprError(); 3665 } 3666 3667 NamedDecl *Member 3668 = cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getMemberDecl())); 3669 if (!Member) 3670 return SemaRef.ExprError(); 3671 3672 if (!getDerived().AlwaysRebuild() && 3673 Base.get() == E->getBase() && 3674 Qualifier == E->getQualifier() && 3675 Member == E->getMemberDecl() && 3676 !E->hasExplicitTemplateArgumentList()) 3677 return SemaRef.Owned(E->Retain()); 3678 3679 TemplateArgumentListInfo TransArgs; 3680 if (E->hasExplicitTemplateArgumentList()) { 3681 TransArgs.setLAngleLoc(E->getLAngleLoc()); 3682 TransArgs.setRAngleLoc(E->getRAngleLoc()); 3683 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 3684 TemplateArgumentLoc Loc; 3685 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc)) 3686 return SemaRef.ExprError(); 3687 TransArgs.addArgument(Loc); 3688 } 3689 } 3690 3691 // FIXME: Bogus source location for the operator 3692 SourceLocation FakeOperatorLoc 3693 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd()); 3694 3695 return getDerived().RebuildMemberExpr(move(Base), FakeOperatorLoc, 3696 E->isArrow(), 3697 Qualifier, 3698 E->getQualifierRange(), 3699 E->getMemberLoc(), 3700 Member, 3701 (E->hasExplicitTemplateArgumentList() 3702 ? &TransArgs : 0), 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>::TransformUnresolvedLookupExpr( 4542 UnresolvedLookupExpr *E, 4543 bool isAddressOfOperand) { 4544 // There is no transformation we can apply to an unresolved lookup. 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>::TransformDependentScopeDeclRefExpr( 4576 DependentScopeDeclRefExpr *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().RebuildDependentScopeDeclRefExpr(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 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 4621 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 4622 TemplateArgumentLoc Loc; 4623 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc)) 4624 return SemaRef.ExprError(); 4625 TransArgs.addArgument(Loc); 4626 } 4627 4628 // FIXME: Would like to avoid rebuilding if nothing changed, but we can't 4629 // compare template arguments (yet). 4630 4631 // FIXME: It's possible that we'll find out now that the template name 4632 // actually refers to a type, in which case the caller is actually dealing 4633 // with a functional cast. Give a reasonable error message! 4634 return getDerived().RebuildTemplateIdExpr(Qualifier, E->getQualifierRange(), 4635 Template, E->getTemplateNameLoc(), 4636 TransArgs); 4637} 4638 4639template<typename Derived> 4640Sema::OwningExprResult 4641TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E, 4642 bool isAddressOfOperand) { 4643 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 4644 4645 QualType T = getDerived().TransformType(E->getType()); 4646 if (T.isNull()) 4647 return SemaRef.ExprError(); 4648 4649 CXXConstructorDecl *Constructor 4650 = cast_or_null<CXXConstructorDecl>( 4651 getDerived().TransformDecl(E->getConstructor())); 4652 if (!Constructor) 4653 return SemaRef.ExprError(); 4654 4655 bool ArgumentChanged = false; 4656 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 4657 for (CXXConstructExpr::arg_iterator Arg = E->arg_begin(), 4658 ArgEnd = E->arg_end(); 4659 Arg != ArgEnd; ++Arg) { 4660 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 4661 if (TransArg.isInvalid()) 4662 return SemaRef.ExprError(); 4663 4664 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 4665 Args.push_back(TransArg.takeAs<Expr>()); 4666 } 4667 4668 if (!getDerived().AlwaysRebuild() && 4669 T == E->getType() && 4670 Constructor == E->getConstructor() && 4671 !ArgumentChanged) 4672 return SemaRef.Owned(E->Retain()); 4673 4674 return getDerived().RebuildCXXConstructExpr(T, Constructor, E->isElidable(), 4675 move_arg(Args)); 4676} 4677 4678/// \brief Transform a C++ temporary-binding expression. 4679/// 4680/// The transformation of a temporary-binding expression always attempts to 4681/// bind a new temporary variable to its subexpression, even if the 4682/// subexpression itself did not change, because the temporary variable itself 4683/// must be unique. 4684template<typename Derived> 4685Sema::OwningExprResult 4686TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E, 4687 bool isAddressOfOperand) { 4688 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4689 if (SubExpr.isInvalid()) 4690 return SemaRef.ExprError(); 4691 4692 return SemaRef.MaybeBindToTemporary(SubExpr.takeAs<Expr>()); 4693} 4694 4695/// \brief Transform a C++ expression that contains temporaries that should 4696/// be destroyed after the expression is evaluated. 4697/// 4698/// The transformation of a full expression always attempts to build a new 4699/// CXXExprWithTemporaries expression, even if the 4700/// subexpression itself did not change, because it will need to capture the 4701/// the new temporary variables introduced in the subexpression. 4702template<typename Derived> 4703Sema::OwningExprResult 4704TreeTransform<Derived>::TransformCXXExprWithTemporaries( 4705 CXXExprWithTemporaries *E, 4706 bool isAddressOfOperand) { 4707 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4708 if (SubExpr.isInvalid()) 4709 return SemaRef.ExprError(); 4710 4711 return SemaRef.Owned( 4712 SemaRef.MaybeCreateCXXExprWithTemporaries(SubExpr.takeAs<Expr>(), 4713 E->shouldDestroyTemporaries())); 4714} 4715 4716template<typename Derived> 4717Sema::OwningExprResult 4718TreeTransform<Derived>::TransformCXXTemporaryObjectExpr( 4719 CXXTemporaryObjectExpr *E, 4720 bool isAddressOfOperand) { 4721 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 4722 QualType T = getDerived().TransformType(E->getType()); 4723 if (T.isNull()) 4724 return SemaRef.ExprError(); 4725 4726 CXXConstructorDecl *Constructor 4727 = cast_or_null<CXXConstructorDecl>( 4728 getDerived().TransformDecl(E->getConstructor())); 4729 if (!Constructor) 4730 return SemaRef.ExprError(); 4731 4732 bool ArgumentChanged = false; 4733 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 4734 Args.reserve(E->getNumArgs()); 4735 for (CXXTemporaryObjectExpr::arg_iterator Arg = E->arg_begin(), 4736 ArgEnd = E->arg_end(); 4737 Arg != ArgEnd; ++Arg) { 4738 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 4739 if (TransArg.isInvalid()) 4740 return SemaRef.ExprError(); 4741 4742 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 4743 Args.push_back((Expr *)TransArg.release()); 4744 } 4745 4746 if (!getDerived().AlwaysRebuild() && 4747 T == E->getType() && 4748 Constructor == E->getConstructor() && 4749 !ArgumentChanged) 4750 return SemaRef.Owned(E->Retain()); 4751 4752 // FIXME: Bogus location information 4753 SourceLocation CommaLoc; 4754 if (Args.size() > 1) { 4755 Expr *First = (Expr *)Args[0]; 4756 CommaLoc 4757 = SemaRef.PP.getLocForEndOfToken(First->getSourceRange().getEnd()); 4758 } 4759 return getDerived().RebuildCXXTemporaryObjectExpr(E->getTypeBeginLoc(), 4760 T, 4761 /*FIXME:*/E->getTypeBeginLoc(), 4762 move_arg(Args), 4763 &CommaLoc, 4764 E->getLocEnd()); 4765} 4766 4767template<typename Derived> 4768Sema::OwningExprResult 4769TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( 4770 CXXUnresolvedConstructExpr *E, 4771 bool isAddressOfOperand) { 4772 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 4773 QualType T = getDerived().TransformType(E->getTypeAsWritten()); 4774 if (T.isNull()) 4775 return SemaRef.ExprError(); 4776 4777 bool ArgumentChanged = false; 4778 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 4779 llvm::SmallVector<SourceLocation, 8> FakeCommaLocs; 4780 for (CXXUnresolvedConstructExpr::arg_iterator Arg = E->arg_begin(), 4781 ArgEnd = E->arg_end(); 4782 Arg != ArgEnd; ++Arg) { 4783 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 4784 if (TransArg.isInvalid()) 4785 return SemaRef.ExprError(); 4786 4787 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 4788 FakeCommaLocs.push_back( 4789 SemaRef.PP.getLocForEndOfToken((*Arg)->getLocEnd())); 4790 Args.push_back(TransArg.takeAs<Expr>()); 4791 } 4792 4793 if (!getDerived().AlwaysRebuild() && 4794 T == E->getTypeAsWritten() && 4795 !ArgumentChanged) 4796 return SemaRef.Owned(E->Retain()); 4797 4798 // FIXME: we're faking the locations of the commas 4799 return getDerived().RebuildCXXUnresolvedConstructExpr(E->getTypeBeginLoc(), 4800 T, 4801 E->getLParenLoc(), 4802 move_arg(Args), 4803 FakeCommaLocs.data(), 4804 E->getRParenLoc()); 4805} 4806 4807template<typename Derived> 4808Sema::OwningExprResult 4809TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr( 4810 CXXDependentScopeMemberExpr *E, 4811 bool isAddressOfOperand) { 4812 // Transform the base of the expression. 4813 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 4814 if (Base.isInvalid()) 4815 return SemaRef.ExprError(); 4816 4817 // Start the member reference and compute the object's type. 4818 Sema::TypeTy *ObjectType = 0; 4819 Base = SemaRef.ActOnStartCXXMemberReference(0, move(Base), 4820 E->getOperatorLoc(), 4821 E->isArrow()? tok::arrow : tok::period, 4822 ObjectType); 4823 if (Base.isInvalid()) 4824 return SemaRef.ExprError(); 4825 4826 // Transform the first part of the nested-name-specifier that qualifies 4827 // the member name. 4828 NamedDecl *FirstQualifierInScope 4829 = getDerived().TransformFirstQualifierInScope( 4830 E->getFirstQualifierFoundInScope(), 4831 E->getQualifierRange().getBegin()); 4832 4833 NestedNameSpecifier *Qualifier = 0; 4834 if (E->getQualifier()) { 4835 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 4836 E->getQualifierRange(), 4837 QualType::getFromOpaquePtr(ObjectType), 4838 FirstQualifierInScope); 4839 if (!Qualifier) 4840 return SemaRef.ExprError(); 4841 } 4842 4843 DeclarationName Name 4844 = getDerived().TransformDeclarationName(E->getMember(), E->getMemberLoc(), 4845 QualType::getFromOpaquePtr(ObjectType)); 4846 if (!Name) 4847 return SemaRef.ExprError(); 4848 4849 if (!E->hasExplicitTemplateArgumentList()) { 4850 // This is a reference to a member without an explicitly-specified 4851 // template argument list. Optimize for this common case. 4852 if (!getDerived().AlwaysRebuild() && 4853 Base.get() == E->getBase() && 4854 Qualifier == E->getQualifier() && 4855 Name == E->getMember() && 4856 FirstQualifierInScope == E->getFirstQualifierFoundInScope()) 4857 return SemaRef.Owned(E->Retain()); 4858 4859 return getDerived().RebuildCXXDependentScopeMemberExpr(move(Base), 4860 E->isArrow(), 4861 E->getOperatorLoc(), 4862 Qualifier, 4863 E->getQualifierRange(), 4864 Name, 4865 E->getMemberLoc(), 4866 FirstQualifierInScope); 4867 } 4868 4869 // FIXME: This is an ugly hack, which forces the same template name to 4870 // be looked up multiple times. Yuck! 4871 TemporaryBase Rebase(*this, E->getMemberLoc(), DeclarationName()); 4872 TemplateName OrigTemplateName; 4873 if (const IdentifierInfo *II = Name.getAsIdentifierInfo()) 4874 OrigTemplateName = SemaRef.Context.getDependentTemplateName(0, II); 4875 else 4876 OrigTemplateName 4877 = SemaRef.Context.getDependentTemplateName(0, 4878 Name.getCXXOverloadedOperator()); 4879 4880 TemplateName Template 4881 = getDerived().TransformTemplateName(OrigTemplateName, 4882 QualType::getFromOpaquePtr(ObjectType)); 4883 if (Template.isNull()) 4884 return SemaRef.ExprError(); 4885 4886 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 4887 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 4888 TemplateArgumentLoc Loc; 4889 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc)) 4890 return SemaRef.ExprError(); 4891 TransArgs.addArgument(Loc); 4892 } 4893 4894 return getDerived().RebuildCXXDependentScopeMemberExpr(move(Base), 4895 E->isArrow(), 4896 E->getOperatorLoc(), 4897 Qualifier, 4898 E->getQualifierRange(), 4899 Template, 4900 E->getMemberLoc(), 4901 FirstQualifierInScope, 4902 TransArgs); 4903} 4904 4905template<typename Derived> 4906Sema::OwningExprResult 4907TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E, 4908 bool isAddressOfOperand) { 4909 return SemaRef.Owned(E->Retain()); 4910} 4911 4912template<typename Derived> 4913Sema::OwningExprResult 4914TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E, 4915 bool isAddressOfOperand) { 4916 // FIXME: poor source location 4917 TemporaryBase Rebase(*this, E->getAtLoc(), DeclarationName()); 4918 QualType EncodedType = getDerived().TransformType(E->getEncodedType()); 4919 if (EncodedType.isNull()) 4920 return SemaRef.ExprError(); 4921 4922 if (!getDerived().AlwaysRebuild() && 4923 EncodedType == E->getEncodedType()) 4924 return SemaRef.Owned(E->Retain()); 4925 4926 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(), 4927 EncodedType, 4928 E->getRParenLoc()); 4929} 4930 4931template<typename Derived> 4932Sema::OwningExprResult 4933TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E, 4934 bool isAddressOfOperand) { 4935 // FIXME: Implement this! 4936 assert(false && "Cannot transform Objective-C expressions yet"); 4937 return SemaRef.Owned(E->Retain()); 4938} 4939 4940template<typename Derived> 4941Sema::OwningExprResult 4942TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E, 4943 bool isAddressOfOperand) { 4944 return SemaRef.Owned(E->Retain()); 4945} 4946 4947template<typename Derived> 4948Sema::OwningExprResult 4949TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E, 4950 bool isAddressOfOperand) { 4951 ObjCProtocolDecl *Protocol 4952 = cast_or_null<ObjCProtocolDecl>( 4953 getDerived().TransformDecl(E->getProtocol())); 4954 if (!Protocol) 4955 return SemaRef.ExprError(); 4956 4957 if (!getDerived().AlwaysRebuild() && 4958 Protocol == E->getProtocol()) 4959 return SemaRef.Owned(E->Retain()); 4960 4961 return getDerived().RebuildObjCProtocolExpr(Protocol, 4962 E->getAtLoc(), 4963 /*FIXME:*/E->getAtLoc(), 4964 /*FIXME:*/E->getAtLoc(), 4965 E->getRParenLoc()); 4966 4967} 4968 4969template<typename Derived> 4970Sema::OwningExprResult 4971TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E, 4972 bool isAddressOfOperand) { 4973 // FIXME: Implement this! 4974 assert(false && "Cannot transform Objective-C expressions yet"); 4975 return SemaRef.Owned(E->Retain()); 4976} 4977 4978template<typename Derived> 4979Sema::OwningExprResult 4980TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E, 4981 bool isAddressOfOperand) { 4982 // FIXME: Implement this! 4983 assert(false && "Cannot transform Objective-C expressions yet"); 4984 return SemaRef.Owned(E->Retain()); 4985} 4986 4987template<typename Derived> 4988Sema::OwningExprResult 4989TreeTransform<Derived>::TransformObjCImplicitSetterGetterRefExpr( 4990 ObjCImplicitSetterGetterRefExpr *E, 4991 bool isAddressOfOperand) { 4992 // FIXME: Implement this! 4993 assert(false && "Cannot transform Objective-C expressions yet"); 4994 return SemaRef.Owned(E->Retain()); 4995} 4996 4997template<typename Derived> 4998Sema::OwningExprResult 4999TreeTransform<Derived>::TransformObjCSuperExpr(ObjCSuperExpr *E, 5000 bool isAddressOfOperand) { 5001 // FIXME: Implement this! 5002 assert(false && "Cannot transform Objective-C expressions yet"); 5003 return SemaRef.Owned(E->Retain()); 5004} 5005 5006template<typename Derived> 5007Sema::OwningExprResult 5008TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E, 5009 bool isAddressOfOperand) { 5010 // FIXME: Implement this! 5011 assert(false && "Cannot transform Objective-C expressions yet"); 5012 return SemaRef.Owned(E->Retain()); 5013} 5014 5015template<typename Derived> 5016Sema::OwningExprResult 5017TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E, 5018 bool isAddressOfOperand) { 5019 bool ArgumentChanged = false; 5020 ASTOwningVector<&ActionBase::DeleteExpr> SubExprs(SemaRef); 5021 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) { 5022 OwningExprResult SubExpr = getDerived().TransformExpr(E->getExpr(I)); 5023 if (SubExpr.isInvalid()) 5024 return SemaRef.ExprError(); 5025 5026 ArgumentChanged = ArgumentChanged || SubExpr.get() != E->getExpr(I); 5027 SubExprs.push_back(SubExpr.takeAs<Expr>()); 5028 } 5029 5030 if (!getDerived().AlwaysRebuild() && 5031 !ArgumentChanged) 5032 return SemaRef.Owned(E->Retain()); 5033 5034 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(), 5035 move_arg(SubExprs), 5036 E->getRParenLoc()); 5037} 5038 5039template<typename Derived> 5040Sema::OwningExprResult 5041TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E, 5042 bool isAddressOfOperand) { 5043 // FIXME: Implement this! 5044 assert(false && "Cannot transform block expressions yet"); 5045 return SemaRef.Owned(E->Retain()); 5046} 5047 5048template<typename Derived> 5049Sema::OwningExprResult 5050TreeTransform<Derived>::TransformBlockDeclRefExpr(BlockDeclRefExpr *E, 5051 bool isAddressOfOperand) { 5052 // FIXME: Implement this! 5053 assert(false && "Cannot transform block-related expressions yet"); 5054 return SemaRef.Owned(E->Retain()); 5055} 5056 5057//===----------------------------------------------------------------------===// 5058// Type reconstruction 5059//===----------------------------------------------------------------------===// 5060 5061template<typename Derived> 5062QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType, 5063 SourceLocation Star) { 5064 return SemaRef.BuildPointerType(PointeeType, Qualifiers(), Star, 5065 getDerived().getBaseEntity()); 5066} 5067 5068template<typename Derived> 5069QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType, 5070 SourceLocation Star) { 5071 return SemaRef.BuildBlockPointerType(PointeeType, Qualifiers(), Star, 5072 getDerived().getBaseEntity()); 5073} 5074 5075template<typename Derived> 5076QualType 5077TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType, 5078 bool WrittenAsLValue, 5079 SourceLocation Sigil) { 5080 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue, Qualifiers(), 5081 Sigil, getDerived().getBaseEntity()); 5082} 5083 5084template<typename Derived> 5085QualType 5086TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType, 5087 QualType ClassType, 5088 SourceLocation Sigil) { 5089 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Qualifiers(), 5090 Sigil, getDerived().getBaseEntity()); 5091} 5092 5093template<typename Derived> 5094QualType 5095TreeTransform<Derived>::RebuildObjCObjectPointerType(QualType PointeeType, 5096 SourceLocation Sigil) { 5097 return SemaRef.BuildPointerType(PointeeType, Qualifiers(), Sigil, 5098 getDerived().getBaseEntity()); 5099} 5100 5101template<typename Derived> 5102QualType 5103TreeTransform<Derived>::RebuildArrayType(QualType ElementType, 5104 ArrayType::ArraySizeModifier SizeMod, 5105 const llvm::APInt *Size, 5106 Expr *SizeExpr, 5107 unsigned IndexTypeQuals, 5108 SourceRange BracketsRange) { 5109 if (SizeExpr || !Size) 5110 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr, 5111 IndexTypeQuals, BracketsRange, 5112 getDerived().getBaseEntity()); 5113 5114 QualType Types[] = { 5115 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy, 5116 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, 5117 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty 5118 }; 5119 const unsigned NumTypes = sizeof(Types) / sizeof(QualType); 5120 QualType SizeType; 5121 for (unsigned I = 0; I != NumTypes; ++I) 5122 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) { 5123 SizeType = Types[I]; 5124 break; 5125 } 5126 5127 if (SizeType.isNull()) 5128 SizeType = SemaRef.Context.getFixedWidthIntType(Size->getBitWidth(), false); 5129 5130 IntegerLiteral ArraySize(*Size, SizeType, /*FIXME*/BracketsRange.getBegin()); 5131 return SemaRef.BuildArrayType(ElementType, SizeMod, &ArraySize, 5132 IndexTypeQuals, BracketsRange, 5133 getDerived().getBaseEntity()); 5134} 5135 5136template<typename Derived> 5137QualType 5138TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType, 5139 ArrayType::ArraySizeModifier SizeMod, 5140 const llvm::APInt &Size, 5141 unsigned IndexTypeQuals, 5142 SourceRange BracketsRange) { 5143 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0, 5144 IndexTypeQuals, BracketsRange); 5145} 5146 5147template<typename Derived> 5148QualType 5149TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType, 5150 ArrayType::ArraySizeModifier SizeMod, 5151 unsigned IndexTypeQuals, 5152 SourceRange BracketsRange) { 5153 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 0, 5154 IndexTypeQuals, BracketsRange); 5155} 5156 5157template<typename Derived> 5158QualType 5159TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType, 5160 ArrayType::ArraySizeModifier SizeMod, 5161 ExprArg SizeExpr, 5162 unsigned IndexTypeQuals, 5163 SourceRange BracketsRange) { 5164 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 5165 SizeExpr.takeAs<Expr>(), 5166 IndexTypeQuals, BracketsRange); 5167} 5168 5169template<typename Derived> 5170QualType 5171TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType, 5172 ArrayType::ArraySizeModifier SizeMod, 5173 ExprArg SizeExpr, 5174 unsigned IndexTypeQuals, 5175 SourceRange BracketsRange) { 5176 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 5177 SizeExpr.takeAs<Expr>(), 5178 IndexTypeQuals, BracketsRange); 5179} 5180 5181template<typename Derived> 5182QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType, 5183 unsigned NumElements) { 5184 // FIXME: semantic checking! 5185 return SemaRef.Context.getVectorType(ElementType, NumElements); 5186} 5187 5188template<typename Derived> 5189QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType, 5190 unsigned NumElements, 5191 SourceLocation AttributeLoc) { 5192 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy), 5193 NumElements, true); 5194 IntegerLiteral *VectorSize 5195 = new (SemaRef.Context) IntegerLiteral(numElements, SemaRef.Context.IntTy, 5196 AttributeLoc); 5197 return SemaRef.BuildExtVectorType(ElementType, SemaRef.Owned(VectorSize), 5198 AttributeLoc); 5199} 5200 5201template<typename Derived> 5202QualType 5203TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType, 5204 ExprArg SizeExpr, 5205 SourceLocation AttributeLoc) { 5206 return SemaRef.BuildExtVectorType(ElementType, move(SizeExpr), AttributeLoc); 5207} 5208 5209template<typename Derived> 5210QualType TreeTransform<Derived>::RebuildFunctionProtoType(QualType T, 5211 QualType *ParamTypes, 5212 unsigned NumParamTypes, 5213 bool Variadic, 5214 unsigned Quals) { 5215 return SemaRef.BuildFunctionType(T, ParamTypes, NumParamTypes, Variadic, 5216 Quals, 5217 getDerived().getBaseLocation(), 5218 getDerived().getBaseEntity()); 5219} 5220 5221template<typename Derived> 5222QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) { 5223 return SemaRef.Context.getFunctionNoProtoType(T); 5224} 5225 5226template<typename Derived> 5227QualType TreeTransform<Derived>::RebuildTypeOfExprType(ExprArg E) { 5228 return SemaRef.BuildTypeofExprType(E.takeAs<Expr>()); 5229} 5230 5231template<typename Derived> 5232QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) { 5233 return SemaRef.Context.getTypeOfType(Underlying); 5234} 5235 5236template<typename Derived> 5237QualType TreeTransform<Derived>::RebuildDecltypeType(ExprArg E) { 5238 return SemaRef.BuildDecltypeType(E.takeAs<Expr>()); 5239} 5240 5241template<typename Derived> 5242QualType TreeTransform<Derived>::RebuildTemplateSpecializationType( 5243 TemplateName Template, 5244 SourceLocation TemplateNameLoc, 5245 const TemplateArgumentListInfo &TemplateArgs) { 5246 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs); 5247} 5248 5249template<typename Derived> 5250NestedNameSpecifier * 5251TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 5252 SourceRange Range, 5253 IdentifierInfo &II, 5254 QualType ObjectType, 5255 NamedDecl *FirstQualifierInScope) { 5256 CXXScopeSpec SS; 5257 // FIXME: The source location information is all wrong. 5258 SS.setRange(Range); 5259 SS.setScopeRep(Prefix); 5260 return static_cast<NestedNameSpecifier *>( 5261 SemaRef.BuildCXXNestedNameSpecifier(0, SS, Range.getEnd(), 5262 Range.getEnd(), II, 5263 ObjectType, 5264 FirstQualifierInScope, 5265 false)); 5266} 5267 5268template<typename Derived> 5269NestedNameSpecifier * 5270TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 5271 SourceRange Range, 5272 NamespaceDecl *NS) { 5273 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, NS); 5274} 5275 5276template<typename Derived> 5277NestedNameSpecifier * 5278TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 5279 SourceRange Range, 5280 bool TemplateKW, 5281 QualType T) { 5282 if (T->isDependentType() || T->isRecordType() || 5283 (SemaRef.getLangOptions().CPlusPlus0x && T->isEnumeralType())) { 5284 assert(!T.hasLocalQualifiers() && "Can't get cv-qualifiers here"); 5285 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, TemplateKW, 5286 T.getTypePtr()); 5287 } 5288 5289 SemaRef.Diag(Range.getBegin(), diag::err_nested_name_spec_non_tag) << T; 5290 return 0; 5291} 5292 5293template<typename Derived> 5294TemplateName 5295TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5296 bool TemplateKW, 5297 TemplateDecl *Template) { 5298 return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW, 5299 Template); 5300} 5301 5302template<typename Derived> 5303TemplateName 5304TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5305 bool TemplateKW, 5306 OverloadedFunctionDecl *Ovl) { 5307 return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW, Ovl); 5308} 5309 5310template<typename Derived> 5311TemplateName 5312TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5313 const IdentifierInfo &II, 5314 QualType ObjectType) { 5315 CXXScopeSpec SS; 5316 SS.setRange(SourceRange(getDerived().getBaseLocation())); 5317 SS.setScopeRep(Qualifier); 5318 UnqualifiedId Name; 5319 Name.setIdentifier(&II, /*FIXME:*/getDerived().getBaseLocation()); 5320 return getSema().ActOnDependentTemplateName( 5321 /*FIXME:*/getDerived().getBaseLocation(), 5322 SS, 5323 Name, 5324 ObjectType.getAsOpaquePtr(), 5325 /*EnteringContext=*/false) 5326 .template getAsVal<TemplateName>(); 5327} 5328 5329template<typename Derived> 5330TemplateName 5331TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5332 OverloadedOperatorKind Operator, 5333 QualType ObjectType) { 5334 CXXScopeSpec SS; 5335 SS.setRange(SourceRange(getDerived().getBaseLocation())); 5336 SS.setScopeRep(Qualifier); 5337 UnqualifiedId Name; 5338 SourceLocation SymbolLocations[3]; // FIXME: Bogus location information. 5339 Name.setOperatorFunctionId(/*FIXME:*/getDerived().getBaseLocation(), 5340 Operator, SymbolLocations); 5341 return getSema().ActOnDependentTemplateName( 5342 /*FIXME:*/getDerived().getBaseLocation(), 5343 SS, 5344 Name, 5345 ObjectType.getAsOpaquePtr(), 5346 /*EnteringContext=*/false) 5347 .template getAsVal<TemplateName>(); 5348} 5349 5350template<typename Derived> 5351Sema::OwningExprResult 5352TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, 5353 SourceLocation OpLoc, 5354 ExprArg Callee, 5355 ExprArg First, 5356 ExprArg Second) { 5357 Expr *FirstExpr = (Expr *)First.get(); 5358 Expr *SecondExpr = (Expr *)Second.get(); 5359 Expr *CalleeExpr = ((Expr *)Callee.get())->IgnoreParenCasts(); 5360 bool isPostIncDec = SecondExpr && (Op == OO_PlusPlus || Op == OO_MinusMinus); 5361 5362 // Determine whether this should be a builtin operation. 5363 if (Op == OO_Subscript) { 5364 if (!FirstExpr->getType()->isOverloadableType() && 5365 !SecondExpr->getType()->isOverloadableType()) 5366 return getSema().CreateBuiltinArraySubscriptExpr(move(First), 5367 CalleeExpr->getLocStart(), 5368 move(Second), OpLoc); 5369 } else if (Op == OO_Arrow) { 5370 // -> is never a builtin operation. 5371 return SemaRef.BuildOverloadedArrowExpr(0, move(First), OpLoc); 5372 } else if (SecondExpr == 0 || isPostIncDec) { 5373 if (!FirstExpr->getType()->isOverloadableType()) { 5374 // The argument is not of overloadable type, so try to create a 5375 // built-in unary operation. 5376 UnaryOperator::Opcode Opc 5377 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 5378 5379 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, move(First)); 5380 } 5381 } else { 5382 if (!FirstExpr->getType()->isOverloadableType() && 5383 !SecondExpr->getType()->isOverloadableType()) { 5384 // Neither of the arguments is an overloadable type, so try to 5385 // create a built-in binary operation. 5386 BinaryOperator::Opcode Opc = BinaryOperator::getOverloadedOpcode(Op); 5387 OwningExprResult Result 5388 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, FirstExpr, SecondExpr); 5389 if (Result.isInvalid()) 5390 return SemaRef.ExprError(); 5391 5392 First.release(); 5393 Second.release(); 5394 return move(Result); 5395 } 5396 } 5397 5398 // Compute the transformed set of functions (and function templates) to be 5399 // used during overload resolution. 5400 Sema::FunctionSet Functions; 5401 5402 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(CalleeExpr)) { 5403 assert(ULE->requiresADL()); 5404 5405 // FIXME: Do we have to check 5406 // IsAcceptableNonMemberOperatorCandidate for each of these? 5407 for (UnresolvedLookupExpr::decls_iterator I = ULE->decls_begin(), 5408 E = ULE->decls_end(); I != E; ++I) 5409 Functions.insert(AnyFunctionDecl::getFromNamedDecl(*I)); 5410 } else { 5411 Functions.insert(AnyFunctionDecl::getFromNamedDecl( 5412 cast<DeclRefExpr>(CalleeExpr)->getDecl())); 5413 } 5414 5415 // Add any functions found via argument-dependent lookup. 5416 Expr *Args[2] = { FirstExpr, SecondExpr }; 5417 unsigned NumArgs = 1 + (SecondExpr != 0); 5418 DeclarationName OpName 5419 = SemaRef.Context.DeclarationNames.getCXXOperatorName(Op); 5420 SemaRef.ArgumentDependentLookup(OpName, /*Operator*/true, Args, NumArgs, 5421 Functions); 5422 5423 // Create the overloaded operator invocation for unary operators. 5424 if (NumArgs == 1 || isPostIncDec) { 5425 UnaryOperator::Opcode Opc 5426 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 5427 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, move(First)); 5428 } 5429 5430 if (Op == OO_Subscript) 5431 return SemaRef.CreateOverloadedArraySubscriptExpr(CalleeExpr->getLocStart(), 5432 OpLoc, 5433 move(First), 5434 move(Second)); 5435 5436 // Create the overloaded operator invocation for binary operators. 5437 BinaryOperator::Opcode Opc = 5438 BinaryOperator::getOverloadedOpcode(Op); 5439 OwningExprResult Result 5440 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]); 5441 if (Result.isInvalid()) 5442 return SemaRef.ExprError(); 5443 5444 First.release(); 5445 Second.release(); 5446 return move(Result); 5447} 5448 5449} // end namespace clang 5450 5451#endif // LLVM_CLANG_SEMA_TREETRANSFORM_H 5452