TreeTransform.h revision 8cfe5a784133d90bf329fd20801824a6f71bb8ca
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(SemaRef); 3088 VarDecl *ConditionVar = 0; 3089 if (S->getConditionVariable()) { 3090 ConditionVar 3091 = cast_or_null<VarDecl>( 3092 getDerived().TransformDefinition(S->getConditionVariable())); 3093 if (!ConditionVar) 3094 return SemaRef.StmtError(); 3095 3096 Cond = getSema().CheckConditionVariable(ConditionVar); 3097 } else 3098 Cond = getDerived().TransformExpr(S->getCond()); 3099 3100 if (Cond.isInvalid()) 3101 return SemaRef.StmtError(); 3102 3103 Sema::FullExprArg FullCond(getSema().FullExpr(Cond)); 3104 3105 // Transform the "then" branch. 3106 OwningStmtResult Then = getDerived().TransformStmt(S->getThen()); 3107 if (Then.isInvalid()) 3108 return SemaRef.StmtError(); 3109 3110 // Transform the "else" branch. 3111 OwningStmtResult Else = getDerived().TransformStmt(S->getElse()); 3112 if (Else.isInvalid()) 3113 return SemaRef.StmtError(); 3114 3115 if (!getDerived().AlwaysRebuild() && 3116 FullCond->get() == S->getCond() && 3117 Then.get() == S->getThen() && 3118 Else.get() == S->getElse()) 3119 return SemaRef.Owned(S->Retain()); 3120 3121 return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, move(Then), 3122 S->getElseLoc(), move(Else)); 3123} 3124 3125template<typename Derived> 3126Sema::OwningStmtResult 3127TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) { 3128 // Transform the condition. 3129 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 3130 if (Cond.isInvalid()) 3131 return SemaRef.StmtError(); 3132 3133 // Rebuild the switch statement. 3134 OwningStmtResult Switch = getDerived().RebuildSwitchStmtStart(move(Cond)); 3135 if (Switch.isInvalid()) 3136 return SemaRef.StmtError(); 3137 3138 // Transform the body of the switch statement. 3139 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3140 if (Body.isInvalid()) 3141 return SemaRef.StmtError(); 3142 3143 // Complete the switch statement. 3144 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), move(Switch), 3145 move(Body)); 3146} 3147 3148template<typename Derived> 3149Sema::OwningStmtResult 3150TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) { 3151 // Transform the condition 3152 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 3153 if (Cond.isInvalid()) 3154 return SemaRef.StmtError(); 3155 3156 Sema::FullExprArg FullCond(getSema().FullExpr(Cond)); 3157 3158 // Transform the body 3159 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3160 if (Body.isInvalid()) 3161 return SemaRef.StmtError(); 3162 3163 if (!getDerived().AlwaysRebuild() && 3164 FullCond->get() == S->getCond() && 3165 Body.get() == S->getBody()) 3166 return SemaRef.Owned(S->Retain()); 3167 3168 return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond, move(Body)); 3169} 3170 3171template<typename Derived> 3172Sema::OwningStmtResult 3173TreeTransform<Derived>::TransformDoStmt(DoStmt *S) { 3174 // Transform the condition 3175 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 3176 if (Cond.isInvalid()) 3177 return SemaRef.StmtError(); 3178 3179 // Transform the body 3180 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3181 if (Body.isInvalid()) 3182 return SemaRef.StmtError(); 3183 3184 if (!getDerived().AlwaysRebuild() && 3185 Cond.get() == S->getCond() && 3186 Body.get() == S->getBody()) 3187 return SemaRef.Owned(S->Retain()); 3188 3189 return getDerived().RebuildDoStmt(S->getDoLoc(), move(Body), S->getWhileLoc(), 3190 /*FIXME:*/S->getWhileLoc(), move(Cond), 3191 S->getRParenLoc()); 3192} 3193 3194template<typename Derived> 3195Sema::OwningStmtResult 3196TreeTransform<Derived>::TransformForStmt(ForStmt *S) { 3197 // Transform the initialization statement 3198 OwningStmtResult Init = getDerived().TransformStmt(S->getInit()); 3199 if (Init.isInvalid()) 3200 return SemaRef.StmtError(); 3201 3202 // Transform the condition 3203 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 3204 if (Cond.isInvalid()) 3205 return SemaRef.StmtError(); 3206 3207 // Transform the increment 3208 OwningExprResult Inc = getDerived().TransformExpr(S->getInc()); 3209 if (Inc.isInvalid()) 3210 return SemaRef.StmtError(); 3211 3212 // Transform the body 3213 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3214 if (Body.isInvalid()) 3215 return SemaRef.StmtError(); 3216 3217 if (!getDerived().AlwaysRebuild() && 3218 Init.get() == S->getInit() && 3219 Cond.get() == S->getCond() && 3220 Inc.get() == S->getInc() && 3221 Body.get() == S->getBody()) 3222 return SemaRef.Owned(S->Retain()); 3223 3224 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(), 3225 move(Init), move(Cond), move(Inc), 3226 S->getRParenLoc(), move(Body)); 3227} 3228 3229template<typename Derived> 3230Sema::OwningStmtResult 3231TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) { 3232 // Goto statements must always be rebuilt, to resolve the label. 3233 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(), 3234 S->getLabel()); 3235} 3236 3237template<typename Derived> 3238Sema::OwningStmtResult 3239TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) { 3240 OwningExprResult Target = getDerived().TransformExpr(S->getTarget()); 3241 if (Target.isInvalid()) 3242 return SemaRef.StmtError(); 3243 3244 if (!getDerived().AlwaysRebuild() && 3245 Target.get() == S->getTarget()) 3246 return SemaRef.Owned(S->Retain()); 3247 3248 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(), 3249 move(Target)); 3250} 3251 3252template<typename Derived> 3253Sema::OwningStmtResult 3254TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) { 3255 return SemaRef.Owned(S->Retain()); 3256} 3257 3258template<typename Derived> 3259Sema::OwningStmtResult 3260TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) { 3261 return SemaRef.Owned(S->Retain()); 3262} 3263 3264template<typename Derived> 3265Sema::OwningStmtResult 3266TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) { 3267 Sema::OwningExprResult Result = getDerived().TransformExpr(S->getRetValue()); 3268 if (Result.isInvalid()) 3269 return SemaRef.StmtError(); 3270 3271 // FIXME: We always rebuild the return statement because there is no way 3272 // to tell whether the return type of the function has changed. 3273 return getDerived().RebuildReturnStmt(S->getReturnLoc(), move(Result)); 3274} 3275 3276template<typename Derived> 3277Sema::OwningStmtResult 3278TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) { 3279 bool DeclChanged = false; 3280 llvm::SmallVector<Decl *, 4> Decls; 3281 for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end(); 3282 D != DEnd; ++D) { 3283 Decl *Transformed = getDerived().TransformDefinition(*D); 3284 if (!Transformed) 3285 return SemaRef.StmtError(); 3286 3287 if (Transformed != *D) 3288 DeclChanged = true; 3289 3290 Decls.push_back(Transformed); 3291 } 3292 3293 if (!getDerived().AlwaysRebuild() && !DeclChanged) 3294 return SemaRef.Owned(S->Retain()); 3295 3296 return getDerived().RebuildDeclStmt(Decls.data(), Decls.size(), 3297 S->getStartLoc(), S->getEndLoc()); 3298} 3299 3300template<typename Derived> 3301Sema::OwningStmtResult 3302TreeTransform<Derived>::TransformSwitchCase(SwitchCase *S) { 3303 assert(false && "SwitchCase is abstract and cannot be transformed"); 3304 return SemaRef.Owned(S->Retain()); 3305} 3306 3307template<typename Derived> 3308Sema::OwningStmtResult 3309TreeTransform<Derived>::TransformAsmStmt(AsmStmt *S) { 3310 // FIXME: Implement! 3311 assert(false && "Inline assembly cannot be transformed"); 3312 return SemaRef.Owned(S->Retain()); 3313} 3314 3315 3316template<typename Derived> 3317Sema::OwningStmtResult 3318TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) { 3319 // FIXME: Implement this 3320 assert(false && "Cannot transform an Objective-C @try statement"); 3321 return SemaRef.Owned(S->Retain()); 3322} 3323 3324template<typename Derived> 3325Sema::OwningStmtResult 3326TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) { 3327 // FIXME: Implement this 3328 assert(false && "Cannot transform an Objective-C @catch statement"); 3329 return SemaRef.Owned(S->Retain()); 3330} 3331 3332template<typename Derived> 3333Sema::OwningStmtResult 3334TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 3335 // FIXME: Implement this 3336 assert(false && "Cannot transform an Objective-C @finally statement"); 3337 return SemaRef.Owned(S->Retain()); 3338} 3339 3340template<typename Derived> 3341Sema::OwningStmtResult 3342TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) { 3343 // FIXME: Implement this 3344 assert(false && "Cannot transform an Objective-C @throw statement"); 3345 return SemaRef.Owned(S->Retain()); 3346} 3347 3348template<typename Derived> 3349Sema::OwningStmtResult 3350TreeTransform<Derived>::TransformObjCAtSynchronizedStmt( 3351 ObjCAtSynchronizedStmt *S) { 3352 // FIXME: Implement this 3353 assert(false && "Cannot transform an Objective-C @synchronized statement"); 3354 return SemaRef.Owned(S->Retain()); 3355} 3356 3357template<typename Derived> 3358Sema::OwningStmtResult 3359TreeTransform<Derived>::TransformObjCForCollectionStmt( 3360 ObjCForCollectionStmt *S) { 3361 // FIXME: Implement this 3362 assert(false && "Cannot transform an Objective-C for-each statement"); 3363 return SemaRef.Owned(S->Retain()); 3364} 3365 3366 3367template<typename Derived> 3368Sema::OwningStmtResult 3369TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) { 3370 // Transform the exception declaration, if any. 3371 VarDecl *Var = 0; 3372 if (S->getExceptionDecl()) { 3373 VarDecl *ExceptionDecl = S->getExceptionDecl(); 3374 TemporaryBase Rebase(*this, ExceptionDecl->getLocation(), 3375 ExceptionDecl->getDeclName()); 3376 3377 QualType T = getDerived().TransformType(ExceptionDecl->getType()); 3378 if (T.isNull()) 3379 return SemaRef.StmtError(); 3380 3381 Var = getDerived().RebuildExceptionDecl(ExceptionDecl, 3382 T, 3383 ExceptionDecl->getDeclaratorInfo(), 3384 ExceptionDecl->getIdentifier(), 3385 ExceptionDecl->getLocation(), 3386 /*FIXME: Inaccurate*/ 3387 SourceRange(ExceptionDecl->getLocation())); 3388 if (!Var || Var->isInvalidDecl()) { 3389 if (Var) 3390 Var->Destroy(SemaRef.Context); 3391 return SemaRef.StmtError(); 3392 } 3393 } 3394 3395 // Transform the actual exception handler. 3396 OwningStmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock()); 3397 if (Handler.isInvalid()) { 3398 if (Var) 3399 Var->Destroy(SemaRef.Context); 3400 return SemaRef.StmtError(); 3401 } 3402 3403 if (!getDerived().AlwaysRebuild() && 3404 !Var && 3405 Handler.get() == S->getHandlerBlock()) 3406 return SemaRef.Owned(S->Retain()); 3407 3408 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), 3409 Var, 3410 move(Handler)); 3411} 3412 3413template<typename Derived> 3414Sema::OwningStmtResult 3415TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) { 3416 // Transform the try block itself. 3417 OwningStmtResult TryBlock 3418 = getDerived().TransformCompoundStmt(S->getTryBlock()); 3419 if (TryBlock.isInvalid()) 3420 return SemaRef.StmtError(); 3421 3422 // Transform the handlers. 3423 bool HandlerChanged = false; 3424 ASTOwningVector<&ActionBase::DeleteStmt> Handlers(SemaRef); 3425 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) { 3426 OwningStmtResult Handler 3427 = getDerived().TransformCXXCatchStmt(S->getHandler(I)); 3428 if (Handler.isInvalid()) 3429 return SemaRef.StmtError(); 3430 3431 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I); 3432 Handlers.push_back(Handler.takeAs<Stmt>()); 3433 } 3434 3435 if (!getDerived().AlwaysRebuild() && 3436 TryBlock.get() == S->getTryBlock() && 3437 !HandlerChanged) 3438 return SemaRef.Owned(S->Retain()); 3439 3440 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), move(TryBlock), 3441 move_arg(Handlers)); 3442} 3443 3444//===----------------------------------------------------------------------===// 3445// Expression transformation 3446//===----------------------------------------------------------------------===// 3447template<typename Derived> 3448Sema::OwningExprResult 3449TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E, 3450 bool isAddressOfOperand) { 3451 return SemaRef.Owned(E->Retain()); 3452} 3453 3454template<typename Derived> 3455Sema::OwningExprResult 3456TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E, 3457 bool isAddressOfOperand) { 3458 NestedNameSpecifier *Qualifier = 0; 3459 if (E->getQualifier()) { 3460 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 3461 E->getQualifierRange()); 3462 if (!Qualifier) 3463 return SemaRef.ExprError(); 3464 } 3465 3466 NamedDecl *ND 3467 = dyn_cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getDecl())); 3468 if (!ND) 3469 return SemaRef.ExprError(); 3470 3471 if (!getDerived().AlwaysRebuild() && 3472 Qualifier == E->getQualifier() && 3473 ND == E->getDecl() && 3474 !E->hasExplicitTemplateArgumentList()) 3475 return SemaRef.Owned(E->Retain()); 3476 3477 // FIXME: We're losing the explicit template arguments in this transformation. 3478 3479 llvm::SmallVector<TemplateArgumentLoc, 4> TransArgs(E->getNumTemplateArgs()); 3480 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 3481 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], 3482 TransArgs[I])) 3483 return SemaRef.ExprError(); 3484 } 3485 3486 // FIXME: Pass the qualifier/qualifier range along. 3487 return getDerived().RebuildDeclRefExpr(Qualifier, E->getQualifierRange(), 3488 ND, E->getLocation(), 3489 isAddressOfOperand); 3490} 3491 3492template<typename Derived> 3493Sema::OwningExprResult 3494TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E, 3495 bool isAddressOfOperand) { 3496 return SemaRef.Owned(E->Retain()); 3497} 3498 3499template<typename Derived> 3500Sema::OwningExprResult 3501TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E, 3502 bool isAddressOfOperand) { 3503 return SemaRef.Owned(E->Retain()); 3504} 3505 3506template<typename Derived> 3507Sema::OwningExprResult 3508TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E, 3509 bool isAddressOfOperand) { 3510 return SemaRef.Owned(E->Retain()); 3511} 3512 3513template<typename Derived> 3514Sema::OwningExprResult 3515TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E, 3516 bool isAddressOfOperand) { 3517 return SemaRef.Owned(E->Retain()); 3518} 3519 3520template<typename Derived> 3521Sema::OwningExprResult 3522TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E, 3523 bool isAddressOfOperand) { 3524 return SemaRef.Owned(E->Retain()); 3525} 3526 3527template<typename Derived> 3528Sema::OwningExprResult 3529TreeTransform<Derived>::TransformParenExpr(ParenExpr *E, 3530 bool isAddressOfOperand) { 3531 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 3532 if (SubExpr.isInvalid()) 3533 return SemaRef.ExprError(); 3534 3535 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 3536 return SemaRef.Owned(E->Retain()); 3537 3538 return getDerived().RebuildParenExpr(move(SubExpr), E->getLParen(), 3539 E->getRParen()); 3540} 3541 3542template<typename Derived> 3543Sema::OwningExprResult 3544TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E, 3545 bool isAddressOfOperand) { 3546 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr(), 3547 E->getOpcode() == UnaryOperator::AddrOf); 3548 if (SubExpr.isInvalid()) 3549 return SemaRef.ExprError(); 3550 3551 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 3552 return SemaRef.Owned(E->Retain()); 3553 3554 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(), 3555 E->getOpcode(), 3556 move(SubExpr)); 3557} 3558 3559template<typename Derived> 3560Sema::OwningExprResult 3561TreeTransform<Derived>::TransformSizeOfAlignOfExpr(SizeOfAlignOfExpr *E, 3562 bool isAddressOfOperand) { 3563 if (E->isArgumentType()) { 3564 DeclaratorInfo *OldT = E->getArgumentTypeInfo(); 3565 3566 DeclaratorInfo *NewT = getDerived().TransformType(OldT); 3567 if (!NewT) 3568 return SemaRef.ExprError(); 3569 3570 if (!getDerived().AlwaysRebuild() && OldT == NewT) 3571 return SemaRef.Owned(E->Retain()); 3572 3573 return getDerived().RebuildSizeOfAlignOf(NewT, E->getOperatorLoc(), 3574 E->isSizeOf(), 3575 E->getSourceRange()); 3576 } 3577 3578 Sema::OwningExprResult SubExpr(SemaRef); 3579 { 3580 // C++0x [expr.sizeof]p1: 3581 // The operand is either an expression, which is an unevaluated operand 3582 // [...] 3583 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 3584 3585 SubExpr = getDerived().TransformExpr(E->getArgumentExpr()); 3586 if (SubExpr.isInvalid()) 3587 return SemaRef.ExprError(); 3588 3589 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr()) 3590 return SemaRef.Owned(E->Retain()); 3591 } 3592 3593 return getDerived().RebuildSizeOfAlignOf(move(SubExpr), E->getOperatorLoc(), 3594 E->isSizeOf(), 3595 E->getSourceRange()); 3596} 3597 3598template<typename Derived> 3599Sema::OwningExprResult 3600TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E, 3601 bool isAddressOfOperand) { 3602 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 3603 if (LHS.isInvalid()) 3604 return SemaRef.ExprError(); 3605 3606 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 3607 if (RHS.isInvalid()) 3608 return SemaRef.ExprError(); 3609 3610 3611 if (!getDerived().AlwaysRebuild() && 3612 LHS.get() == E->getLHS() && 3613 RHS.get() == E->getRHS()) 3614 return SemaRef.Owned(E->Retain()); 3615 3616 return getDerived().RebuildArraySubscriptExpr(move(LHS), 3617 /*FIXME:*/E->getLHS()->getLocStart(), 3618 move(RHS), 3619 E->getRBracketLoc()); 3620} 3621 3622template<typename Derived> 3623Sema::OwningExprResult 3624TreeTransform<Derived>::TransformCallExpr(CallExpr *E, 3625 bool isAddressOfOperand) { 3626 // Transform the callee. 3627 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee()); 3628 if (Callee.isInvalid()) 3629 return SemaRef.ExprError(); 3630 3631 // Transform arguments. 3632 bool ArgChanged = false; 3633 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 3634 llvm::SmallVector<SourceLocation, 4> FakeCommaLocs; 3635 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) { 3636 OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I)); 3637 if (Arg.isInvalid()) 3638 return SemaRef.ExprError(); 3639 3640 // FIXME: Wrong source location information for the ','. 3641 FakeCommaLocs.push_back( 3642 SemaRef.PP.getLocForEndOfToken(E->getArg(I)->getSourceRange().getEnd())); 3643 3644 ArgChanged = ArgChanged || Arg.get() != E->getArg(I); 3645 Args.push_back(Arg.takeAs<Expr>()); 3646 } 3647 3648 if (!getDerived().AlwaysRebuild() && 3649 Callee.get() == E->getCallee() && 3650 !ArgChanged) 3651 return SemaRef.Owned(E->Retain()); 3652 3653 // FIXME: Wrong source location information for the '('. 3654 SourceLocation FakeLParenLoc 3655 = ((Expr *)Callee.get())->getSourceRange().getBegin(); 3656 return getDerived().RebuildCallExpr(move(Callee), FakeLParenLoc, 3657 move_arg(Args), 3658 FakeCommaLocs.data(), 3659 E->getRParenLoc()); 3660} 3661 3662template<typename Derived> 3663Sema::OwningExprResult 3664TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E, 3665 bool isAddressOfOperand) { 3666 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 3667 if (Base.isInvalid()) 3668 return SemaRef.ExprError(); 3669 3670 NestedNameSpecifier *Qualifier = 0; 3671 if (E->hasQualifier()) { 3672 Qualifier 3673 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 3674 E->getQualifierRange()); 3675 if (Qualifier == 0) 3676 return SemaRef.ExprError(); 3677 } 3678 3679 NamedDecl *Member 3680 = cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getMemberDecl())); 3681 if (!Member) 3682 return SemaRef.ExprError(); 3683 3684 if (!getDerived().AlwaysRebuild() && 3685 Base.get() == E->getBase() && 3686 Qualifier == E->getQualifier() && 3687 Member == E->getMemberDecl() && 3688 !E->hasExplicitTemplateArgumentList()) 3689 return SemaRef.Owned(E->Retain()); 3690 3691 TemplateArgumentListInfo TransArgs; 3692 if (E->hasExplicitTemplateArgumentList()) { 3693 TransArgs.setLAngleLoc(E->getLAngleLoc()); 3694 TransArgs.setRAngleLoc(E->getRAngleLoc()); 3695 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 3696 TemplateArgumentLoc Loc; 3697 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc)) 3698 return SemaRef.ExprError(); 3699 TransArgs.addArgument(Loc); 3700 } 3701 } 3702 3703 // FIXME: Bogus source location for the operator 3704 SourceLocation FakeOperatorLoc 3705 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd()); 3706 3707 return getDerived().RebuildMemberExpr(move(Base), FakeOperatorLoc, 3708 E->isArrow(), 3709 Qualifier, 3710 E->getQualifierRange(), 3711 E->getMemberLoc(), 3712 Member, 3713 (E->hasExplicitTemplateArgumentList() 3714 ? &TransArgs : 0), 3715 0); 3716} 3717 3718template<typename Derived> 3719Sema::OwningExprResult 3720TreeTransform<Derived>::TransformCastExpr(CastExpr *E, 3721 bool isAddressOfOperand) { 3722 assert(false && "Cannot transform abstract class"); 3723 return SemaRef.Owned(E->Retain()); 3724} 3725 3726template<typename Derived> 3727Sema::OwningExprResult 3728TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E, 3729 bool isAddressOfOperand) { 3730 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 3731 if (LHS.isInvalid()) 3732 return SemaRef.ExprError(); 3733 3734 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 3735 if (RHS.isInvalid()) 3736 return SemaRef.ExprError(); 3737 3738 if (!getDerived().AlwaysRebuild() && 3739 LHS.get() == E->getLHS() && 3740 RHS.get() == E->getRHS()) 3741 return SemaRef.Owned(E->Retain()); 3742 3743 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(), 3744 move(LHS), move(RHS)); 3745} 3746 3747template<typename Derived> 3748Sema::OwningExprResult 3749TreeTransform<Derived>::TransformCompoundAssignOperator( 3750 CompoundAssignOperator *E, 3751 bool isAddressOfOperand) { 3752 return getDerived().TransformBinaryOperator(E, isAddressOfOperand); 3753} 3754 3755template<typename Derived> 3756Sema::OwningExprResult 3757TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E, 3758 bool isAddressOfOperand) { 3759 OwningExprResult Cond = getDerived().TransformExpr(E->getCond()); 3760 if (Cond.isInvalid()) 3761 return SemaRef.ExprError(); 3762 3763 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 3764 if (LHS.isInvalid()) 3765 return SemaRef.ExprError(); 3766 3767 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 3768 if (RHS.isInvalid()) 3769 return SemaRef.ExprError(); 3770 3771 if (!getDerived().AlwaysRebuild() && 3772 Cond.get() == E->getCond() && 3773 LHS.get() == E->getLHS() && 3774 RHS.get() == E->getRHS()) 3775 return SemaRef.Owned(E->Retain()); 3776 3777 return getDerived().RebuildConditionalOperator(move(Cond), 3778 E->getQuestionLoc(), 3779 move(LHS), 3780 E->getColonLoc(), 3781 move(RHS)); 3782} 3783 3784template<typename Derived> 3785Sema::OwningExprResult 3786TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E, 3787 bool isAddressOfOperand) { 3788 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 3789 3790 // FIXME: Will we ever have type information here? It seems like we won't, 3791 // so do we even need to transform the type? 3792 QualType T = getDerived().TransformType(E->getType()); 3793 if (T.isNull()) 3794 return SemaRef.ExprError(); 3795 3796 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 3797 if (SubExpr.isInvalid()) 3798 return SemaRef.ExprError(); 3799 3800 if (!getDerived().AlwaysRebuild() && 3801 T == E->getType() && 3802 SubExpr.get() == E->getSubExpr()) 3803 return SemaRef.Owned(E->Retain()); 3804 3805 return getDerived().RebuildImplicitCastExpr(T, E->getCastKind(), 3806 move(SubExpr), 3807 E->isLvalueCast()); 3808} 3809 3810template<typename Derived> 3811Sema::OwningExprResult 3812TreeTransform<Derived>::TransformExplicitCastExpr(ExplicitCastExpr *E, 3813 bool isAddressOfOperand) { 3814 assert(false && "Cannot transform abstract class"); 3815 return SemaRef.Owned(E->Retain()); 3816} 3817 3818template<typename Derived> 3819Sema::OwningExprResult 3820TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E, 3821 bool isAddressOfOperand) { 3822 QualType T; 3823 { 3824 // FIXME: Source location isn't quite accurate. 3825 SourceLocation TypeStartLoc 3826 = SemaRef.PP.getLocForEndOfToken(E->getLParenLoc()); 3827 TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName()); 3828 3829 T = getDerived().TransformType(E->getTypeAsWritten()); 3830 if (T.isNull()) 3831 return SemaRef.ExprError(); 3832 } 3833 3834 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 3835 if (SubExpr.isInvalid()) 3836 return SemaRef.ExprError(); 3837 3838 if (!getDerived().AlwaysRebuild() && 3839 T == E->getTypeAsWritten() && 3840 SubExpr.get() == E->getSubExpr()) 3841 return SemaRef.Owned(E->Retain()); 3842 3843 return getDerived().RebuildCStyleCaseExpr(E->getLParenLoc(), T, 3844 E->getRParenLoc(), 3845 move(SubExpr)); 3846} 3847 3848template<typename Derived> 3849Sema::OwningExprResult 3850TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E, 3851 bool isAddressOfOperand) { 3852 QualType T; 3853 { 3854 // FIXME: Source location isn't quite accurate. 3855 SourceLocation FakeTypeLoc 3856 = SemaRef.PP.getLocForEndOfToken(E->getLParenLoc()); 3857 TemporaryBase Rebase(*this, FakeTypeLoc, DeclarationName()); 3858 3859 T = getDerived().TransformType(E->getType()); 3860 if (T.isNull()) 3861 return SemaRef.ExprError(); 3862 } 3863 3864 OwningExprResult Init = getDerived().TransformExpr(E->getInitializer()); 3865 if (Init.isInvalid()) 3866 return SemaRef.ExprError(); 3867 3868 if (!getDerived().AlwaysRebuild() && 3869 T == E->getType() && 3870 Init.get() == E->getInitializer()) 3871 return SemaRef.Owned(E->Retain()); 3872 3873 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), T, 3874 /*FIXME:*/E->getInitializer()->getLocEnd(), 3875 move(Init)); 3876} 3877 3878template<typename Derived> 3879Sema::OwningExprResult 3880TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E, 3881 bool isAddressOfOperand) { 3882 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 3883 if (Base.isInvalid()) 3884 return SemaRef.ExprError(); 3885 3886 if (!getDerived().AlwaysRebuild() && 3887 Base.get() == E->getBase()) 3888 return SemaRef.Owned(E->Retain()); 3889 3890 // FIXME: Bad source location 3891 SourceLocation FakeOperatorLoc 3892 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getLocEnd()); 3893 return getDerived().RebuildExtVectorElementExpr(move(Base), FakeOperatorLoc, 3894 E->getAccessorLoc(), 3895 E->getAccessor()); 3896} 3897 3898template<typename Derived> 3899Sema::OwningExprResult 3900TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E, 3901 bool isAddressOfOperand) { 3902 bool InitChanged = false; 3903 3904 ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef); 3905 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) { 3906 OwningExprResult Init = getDerived().TransformExpr(E->getInit(I)); 3907 if (Init.isInvalid()) 3908 return SemaRef.ExprError(); 3909 3910 InitChanged = InitChanged || Init.get() != E->getInit(I); 3911 Inits.push_back(Init.takeAs<Expr>()); 3912 } 3913 3914 if (!getDerived().AlwaysRebuild() && !InitChanged) 3915 return SemaRef.Owned(E->Retain()); 3916 3917 return getDerived().RebuildInitList(E->getLBraceLoc(), move_arg(Inits), 3918 E->getRBraceLoc(), E->getType()); 3919} 3920 3921template<typename Derived> 3922Sema::OwningExprResult 3923TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E, 3924 bool isAddressOfOperand) { 3925 Designation Desig; 3926 3927 // transform the initializer value 3928 OwningExprResult Init = getDerived().TransformExpr(E->getInit()); 3929 if (Init.isInvalid()) 3930 return SemaRef.ExprError(); 3931 3932 // transform the designators. 3933 ASTOwningVector<&ActionBase::DeleteExpr, 4> ArrayExprs(SemaRef); 3934 bool ExprChanged = false; 3935 for (DesignatedInitExpr::designators_iterator D = E->designators_begin(), 3936 DEnd = E->designators_end(); 3937 D != DEnd; ++D) { 3938 if (D->isFieldDesignator()) { 3939 Desig.AddDesignator(Designator::getField(D->getFieldName(), 3940 D->getDotLoc(), 3941 D->getFieldLoc())); 3942 continue; 3943 } 3944 3945 if (D->isArrayDesignator()) { 3946 OwningExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D)); 3947 if (Index.isInvalid()) 3948 return SemaRef.ExprError(); 3949 3950 Desig.AddDesignator(Designator::getArray(Index.get(), 3951 D->getLBracketLoc())); 3952 3953 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D); 3954 ArrayExprs.push_back(Index.release()); 3955 continue; 3956 } 3957 3958 assert(D->isArrayRangeDesignator() && "New kind of designator?"); 3959 OwningExprResult Start 3960 = getDerived().TransformExpr(E->getArrayRangeStart(*D)); 3961 if (Start.isInvalid()) 3962 return SemaRef.ExprError(); 3963 3964 OwningExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D)); 3965 if (End.isInvalid()) 3966 return SemaRef.ExprError(); 3967 3968 Desig.AddDesignator(Designator::getArrayRange(Start.get(), 3969 End.get(), 3970 D->getLBracketLoc(), 3971 D->getEllipsisLoc())); 3972 3973 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) || 3974 End.get() != E->getArrayRangeEnd(*D); 3975 3976 ArrayExprs.push_back(Start.release()); 3977 ArrayExprs.push_back(End.release()); 3978 } 3979 3980 if (!getDerived().AlwaysRebuild() && 3981 Init.get() == E->getInit() && 3982 !ExprChanged) 3983 return SemaRef.Owned(E->Retain()); 3984 3985 return getDerived().RebuildDesignatedInitExpr(Desig, move_arg(ArrayExprs), 3986 E->getEqualOrColonLoc(), 3987 E->usesGNUSyntax(), move(Init)); 3988} 3989 3990template<typename Derived> 3991Sema::OwningExprResult 3992TreeTransform<Derived>::TransformImplicitValueInitExpr( 3993 ImplicitValueInitExpr *E, 3994 bool isAddressOfOperand) { 3995 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 3996 3997 // FIXME: Will we ever have proper type location here? Will we actually 3998 // need to transform the type? 3999 QualType T = getDerived().TransformType(E->getType()); 4000 if (T.isNull()) 4001 return SemaRef.ExprError(); 4002 4003 if (!getDerived().AlwaysRebuild() && 4004 T == E->getType()) 4005 return SemaRef.Owned(E->Retain()); 4006 4007 return getDerived().RebuildImplicitValueInitExpr(T); 4008} 4009 4010template<typename Derived> 4011Sema::OwningExprResult 4012TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E, 4013 bool isAddressOfOperand) { 4014 // FIXME: Do we want the type as written? 4015 QualType T; 4016 4017 { 4018 // FIXME: Source location isn't quite accurate. 4019 TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName()); 4020 T = getDerived().TransformType(E->getType()); 4021 if (T.isNull()) 4022 return SemaRef.ExprError(); 4023 } 4024 4025 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4026 if (SubExpr.isInvalid()) 4027 return SemaRef.ExprError(); 4028 4029 if (!getDerived().AlwaysRebuild() && 4030 T == E->getType() && 4031 SubExpr.get() == E->getSubExpr()) 4032 return SemaRef.Owned(E->Retain()); 4033 4034 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), move(SubExpr), 4035 T, E->getRParenLoc()); 4036} 4037 4038template<typename Derived> 4039Sema::OwningExprResult 4040TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E, 4041 bool isAddressOfOperand) { 4042 bool ArgumentChanged = false; 4043 ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef); 4044 for (unsigned I = 0, N = E->getNumExprs(); I != N; ++I) { 4045 OwningExprResult Init = getDerived().TransformExpr(E->getExpr(I)); 4046 if (Init.isInvalid()) 4047 return SemaRef.ExprError(); 4048 4049 ArgumentChanged = ArgumentChanged || Init.get() != E->getExpr(I); 4050 Inits.push_back(Init.takeAs<Expr>()); 4051 } 4052 4053 return getDerived().RebuildParenListExpr(E->getLParenLoc(), 4054 move_arg(Inits), 4055 E->getRParenLoc()); 4056} 4057 4058/// \brief Transform an address-of-label expression. 4059/// 4060/// By default, the transformation of an address-of-label expression always 4061/// rebuilds the expression, so that the label identifier can be resolved to 4062/// the corresponding label statement by semantic analysis. 4063template<typename Derived> 4064Sema::OwningExprResult 4065TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E, 4066 bool isAddressOfOperand) { 4067 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(), 4068 E->getLabel()); 4069} 4070 4071template<typename Derived> 4072Sema::OwningExprResult 4073TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E, 4074 bool isAddressOfOperand) { 4075 OwningStmtResult SubStmt 4076 = getDerived().TransformCompoundStmt(E->getSubStmt(), true); 4077 if (SubStmt.isInvalid()) 4078 return SemaRef.ExprError(); 4079 4080 if (!getDerived().AlwaysRebuild() && 4081 SubStmt.get() == E->getSubStmt()) 4082 return SemaRef.Owned(E->Retain()); 4083 4084 return getDerived().RebuildStmtExpr(E->getLParenLoc(), 4085 move(SubStmt), 4086 E->getRParenLoc()); 4087} 4088 4089template<typename Derived> 4090Sema::OwningExprResult 4091TreeTransform<Derived>::TransformTypesCompatibleExpr(TypesCompatibleExpr *E, 4092 bool isAddressOfOperand) { 4093 QualType T1, T2; 4094 { 4095 // FIXME: Source location isn't quite accurate. 4096 TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName()); 4097 4098 T1 = getDerived().TransformType(E->getArgType1()); 4099 if (T1.isNull()) 4100 return SemaRef.ExprError(); 4101 4102 T2 = getDerived().TransformType(E->getArgType2()); 4103 if (T2.isNull()) 4104 return SemaRef.ExprError(); 4105 } 4106 4107 if (!getDerived().AlwaysRebuild() && 4108 T1 == E->getArgType1() && 4109 T2 == E->getArgType2()) 4110 return SemaRef.Owned(E->Retain()); 4111 4112 return getDerived().RebuildTypesCompatibleExpr(E->getBuiltinLoc(), 4113 T1, T2, E->getRParenLoc()); 4114} 4115 4116template<typename Derived> 4117Sema::OwningExprResult 4118TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E, 4119 bool isAddressOfOperand) { 4120 OwningExprResult Cond = getDerived().TransformExpr(E->getCond()); 4121 if (Cond.isInvalid()) 4122 return SemaRef.ExprError(); 4123 4124 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 4125 if (LHS.isInvalid()) 4126 return SemaRef.ExprError(); 4127 4128 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 4129 if (RHS.isInvalid()) 4130 return SemaRef.ExprError(); 4131 4132 if (!getDerived().AlwaysRebuild() && 4133 Cond.get() == E->getCond() && 4134 LHS.get() == E->getLHS() && 4135 RHS.get() == E->getRHS()) 4136 return SemaRef.Owned(E->Retain()); 4137 4138 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(), 4139 move(Cond), move(LHS), move(RHS), 4140 E->getRParenLoc()); 4141} 4142 4143template<typename Derived> 4144Sema::OwningExprResult 4145TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E, 4146 bool isAddressOfOperand) { 4147 return SemaRef.Owned(E->Retain()); 4148} 4149 4150template<typename Derived> 4151Sema::OwningExprResult 4152TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E, 4153 bool isAddressOfOperand) { 4154 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee()); 4155 if (Callee.isInvalid()) 4156 return SemaRef.ExprError(); 4157 4158 OwningExprResult First 4159 = getDerived().TransformExpr(E->getArg(0), 4160 E->getNumArgs() == 1 && E->getOperator() == OO_Amp); 4161 if (First.isInvalid()) 4162 return SemaRef.ExprError(); 4163 4164 OwningExprResult Second(SemaRef); 4165 if (E->getNumArgs() == 2) { 4166 Second = getDerived().TransformExpr(E->getArg(1)); 4167 if (Second.isInvalid()) 4168 return SemaRef.ExprError(); 4169 } 4170 4171 if (!getDerived().AlwaysRebuild() && 4172 Callee.get() == E->getCallee() && 4173 First.get() == E->getArg(0) && 4174 (E->getNumArgs() != 2 || Second.get() == E->getArg(1))) 4175 return SemaRef.Owned(E->Retain()); 4176 4177 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(), 4178 E->getOperatorLoc(), 4179 move(Callee), 4180 move(First), 4181 move(Second)); 4182} 4183 4184template<typename Derived> 4185Sema::OwningExprResult 4186TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E, 4187 bool isAddressOfOperand) { 4188 return getDerived().TransformCallExpr(E, isAddressOfOperand); 4189} 4190 4191template<typename Derived> 4192Sema::OwningExprResult 4193TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E, 4194 bool isAddressOfOperand) { 4195 QualType ExplicitTy; 4196 { 4197 // FIXME: Source location isn't quite accurate. 4198 SourceLocation TypeStartLoc 4199 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc()); 4200 TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName()); 4201 4202 ExplicitTy = getDerived().TransformType(E->getTypeAsWritten()); 4203 if (ExplicitTy.isNull()) 4204 return SemaRef.ExprError(); 4205 } 4206 4207 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4208 if (SubExpr.isInvalid()) 4209 return SemaRef.ExprError(); 4210 4211 if (!getDerived().AlwaysRebuild() && 4212 ExplicitTy == E->getTypeAsWritten() && 4213 SubExpr.get() == E->getSubExpr()) 4214 return SemaRef.Owned(E->Retain()); 4215 4216 // FIXME: Poor source location information here. 4217 SourceLocation FakeLAngleLoc 4218 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc()); 4219 SourceLocation FakeRAngleLoc = E->getSubExpr()->getSourceRange().getBegin(); 4220 SourceLocation FakeRParenLoc 4221 = SemaRef.PP.getLocForEndOfToken( 4222 E->getSubExpr()->getSourceRange().getEnd()); 4223 return getDerived().RebuildCXXNamedCastExpr(E->getOperatorLoc(), 4224 E->getStmtClass(), 4225 FakeLAngleLoc, 4226 ExplicitTy, 4227 FakeRAngleLoc, 4228 FakeRAngleLoc, 4229 move(SubExpr), 4230 FakeRParenLoc); 4231} 4232 4233template<typename Derived> 4234Sema::OwningExprResult 4235TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E, 4236 bool isAddressOfOperand) { 4237 return getDerived().TransformCXXNamedCastExpr(E, isAddressOfOperand); 4238} 4239 4240template<typename Derived> 4241Sema::OwningExprResult 4242TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E, 4243 bool isAddressOfOperand) { 4244 return getDerived().TransformCXXNamedCastExpr(E, isAddressOfOperand); 4245} 4246 4247template<typename Derived> 4248Sema::OwningExprResult 4249TreeTransform<Derived>::TransformCXXReinterpretCastExpr( 4250 CXXReinterpretCastExpr *E, 4251 bool isAddressOfOperand) { 4252 return getDerived().TransformCXXNamedCastExpr(E, isAddressOfOperand); 4253} 4254 4255template<typename Derived> 4256Sema::OwningExprResult 4257TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E, 4258 bool isAddressOfOperand) { 4259 return getDerived().TransformCXXNamedCastExpr(E, isAddressOfOperand); 4260} 4261 4262template<typename Derived> 4263Sema::OwningExprResult 4264TreeTransform<Derived>::TransformCXXFunctionalCastExpr( 4265 CXXFunctionalCastExpr *E, 4266 bool isAddressOfOperand) { 4267 QualType ExplicitTy; 4268 { 4269 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 4270 4271 ExplicitTy = getDerived().TransformType(E->getTypeAsWritten()); 4272 if (ExplicitTy.isNull()) 4273 return SemaRef.ExprError(); 4274 } 4275 4276 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4277 if (SubExpr.isInvalid()) 4278 return SemaRef.ExprError(); 4279 4280 if (!getDerived().AlwaysRebuild() && 4281 ExplicitTy == E->getTypeAsWritten() && 4282 SubExpr.get() == E->getSubExpr()) 4283 return SemaRef.Owned(E->Retain()); 4284 4285 // FIXME: The end of the type's source range is wrong 4286 return getDerived().RebuildCXXFunctionalCastExpr( 4287 /*FIXME:*/SourceRange(E->getTypeBeginLoc()), 4288 ExplicitTy, 4289 /*FIXME:*/E->getSubExpr()->getLocStart(), 4290 move(SubExpr), 4291 E->getRParenLoc()); 4292} 4293 4294template<typename Derived> 4295Sema::OwningExprResult 4296TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E, 4297 bool isAddressOfOperand) { 4298 if (E->isTypeOperand()) { 4299 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 4300 4301 QualType T = getDerived().TransformType(E->getTypeOperand()); 4302 if (T.isNull()) 4303 return SemaRef.ExprError(); 4304 4305 if (!getDerived().AlwaysRebuild() && 4306 T == E->getTypeOperand()) 4307 return SemaRef.Owned(E->Retain()); 4308 4309 return getDerived().RebuildCXXTypeidExpr(E->getLocStart(), 4310 /*FIXME:*/E->getLocStart(), 4311 T, 4312 E->getLocEnd()); 4313 } 4314 4315 // We don't know whether the expression is potentially evaluated until 4316 // after we perform semantic analysis, so the expression is potentially 4317 // potentially evaluated. 4318 EnterExpressionEvaluationContext Unevaluated(SemaRef, 4319 Action::PotentiallyPotentiallyEvaluated); 4320 4321 OwningExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); 4322 if (SubExpr.isInvalid()) 4323 return SemaRef.ExprError(); 4324 4325 if (!getDerived().AlwaysRebuild() && 4326 SubExpr.get() == E->getExprOperand()) 4327 return SemaRef.Owned(E->Retain()); 4328 4329 return getDerived().RebuildCXXTypeidExpr(E->getLocStart(), 4330 /*FIXME:*/E->getLocStart(), 4331 move(SubExpr), 4332 E->getLocEnd()); 4333} 4334 4335template<typename Derived> 4336Sema::OwningExprResult 4337TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E, 4338 bool isAddressOfOperand) { 4339 return SemaRef.Owned(E->Retain()); 4340} 4341 4342template<typename Derived> 4343Sema::OwningExprResult 4344TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr( 4345 CXXNullPtrLiteralExpr *E, 4346 bool isAddressOfOperand) { 4347 return SemaRef.Owned(E->Retain()); 4348} 4349 4350template<typename Derived> 4351Sema::OwningExprResult 4352TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E, 4353 bool isAddressOfOperand) { 4354 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 4355 4356 QualType T = getDerived().TransformType(E->getType()); 4357 if (T.isNull()) 4358 return SemaRef.ExprError(); 4359 4360 if (!getDerived().AlwaysRebuild() && 4361 T == E->getType()) 4362 return SemaRef.Owned(E->Retain()); 4363 4364 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T); 4365} 4366 4367template<typename Derived> 4368Sema::OwningExprResult 4369TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E, 4370 bool isAddressOfOperand) { 4371 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4372 if (SubExpr.isInvalid()) 4373 return SemaRef.ExprError(); 4374 4375 if (!getDerived().AlwaysRebuild() && 4376 SubExpr.get() == E->getSubExpr()) 4377 return SemaRef.Owned(E->Retain()); 4378 4379 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), move(SubExpr)); 4380} 4381 4382template<typename Derived> 4383Sema::OwningExprResult 4384TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E, 4385 bool isAddressOfOperand) { 4386 ParmVarDecl *Param 4387 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getParam())); 4388 if (!Param) 4389 return SemaRef.ExprError(); 4390 4391 if (getDerived().AlwaysRebuild() && 4392 Param == E->getParam()) 4393 return SemaRef.Owned(E->Retain()); 4394 4395 return getDerived().RebuildCXXDefaultArgExpr(Param); 4396} 4397 4398template<typename Derived> 4399Sema::OwningExprResult 4400TreeTransform<Derived>::TransformCXXZeroInitValueExpr(CXXZeroInitValueExpr *E, 4401 bool isAddressOfOperand) { 4402 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 4403 4404 QualType T = getDerived().TransformType(E->getType()); 4405 if (T.isNull()) 4406 return SemaRef.ExprError(); 4407 4408 if (!getDerived().AlwaysRebuild() && 4409 T == E->getType()) 4410 return SemaRef.Owned(E->Retain()); 4411 4412 return getDerived().RebuildCXXZeroInitValueExpr(E->getTypeBeginLoc(), 4413 /*FIXME:*/E->getTypeBeginLoc(), 4414 T, 4415 E->getRParenLoc()); 4416} 4417 4418template<typename Derived> 4419Sema::OwningExprResult 4420TreeTransform<Derived>::TransformCXXConditionDeclExpr(CXXConditionDeclExpr *E, 4421 bool isAddressOfOperand) { 4422 VarDecl *Var 4423 = cast_or_null<VarDecl>(getDerived().TransformDefinition(E->getVarDecl())); 4424 if (!Var) 4425 return SemaRef.ExprError(); 4426 4427 if (!getDerived().AlwaysRebuild() && 4428 Var == E->getVarDecl()) 4429 return SemaRef.Owned(E->Retain()); 4430 4431 return getDerived().RebuildCXXConditionDeclExpr(E->getStartLoc(), 4432 /*FIXME:*/E->getStartLoc(), 4433 Var); 4434} 4435 4436template<typename Derived> 4437Sema::OwningExprResult 4438TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E, 4439 bool isAddressOfOperand) { 4440 // Transform the type that we're allocating 4441 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 4442 QualType AllocType = getDerived().TransformType(E->getAllocatedType()); 4443 if (AllocType.isNull()) 4444 return SemaRef.ExprError(); 4445 4446 // Transform the size of the array we're allocating (if any). 4447 OwningExprResult ArraySize = getDerived().TransformExpr(E->getArraySize()); 4448 if (ArraySize.isInvalid()) 4449 return SemaRef.ExprError(); 4450 4451 // Transform the placement arguments (if any). 4452 bool ArgumentChanged = false; 4453 ASTOwningVector<&ActionBase::DeleteExpr> PlacementArgs(SemaRef); 4454 for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) { 4455 OwningExprResult Arg = getDerived().TransformExpr(E->getPlacementArg(I)); 4456 if (Arg.isInvalid()) 4457 return SemaRef.ExprError(); 4458 4459 ArgumentChanged = ArgumentChanged || Arg.get() != E->getPlacementArg(I); 4460 PlacementArgs.push_back(Arg.take()); 4461 } 4462 4463 // transform the constructor arguments (if any). 4464 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(SemaRef); 4465 for (unsigned I = 0, N = E->getNumConstructorArgs(); I != N; ++I) { 4466 OwningExprResult Arg = getDerived().TransformExpr(E->getConstructorArg(I)); 4467 if (Arg.isInvalid()) 4468 return SemaRef.ExprError(); 4469 4470 ArgumentChanged = ArgumentChanged || Arg.get() != E->getConstructorArg(I); 4471 ConstructorArgs.push_back(Arg.take()); 4472 } 4473 4474 if (!getDerived().AlwaysRebuild() && 4475 AllocType == E->getAllocatedType() && 4476 ArraySize.get() == E->getArraySize() && 4477 !ArgumentChanged) 4478 return SemaRef.Owned(E->Retain()); 4479 4480 return getDerived().RebuildCXXNewExpr(E->getLocStart(), 4481 E->isGlobalNew(), 4482 /*FIXME:*/E->getLocStart(), 4483 move_arg(PlacementArgs), 4484 /*FIXME:*/E->getLocStart(), 4485 E->isParenTypeId(), 4486 AllocType, 4487 /*FIXME:*/E->getLocStart(), 4488 /*FIXME:*/SourceRange(), 4489 move(ArraySize), 4490 /*FIXME:*/E->getLocStart(), 4491 move_arg(ConstructorArgs), 4492 E->getLocEnd()); 4493} 4494 4495template<typename Derived> 4496Sema::OwningExprResult 4497TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E, 4498 bool isAddressOfOperand) { 4499 OwningExprResult Operand = getDerived().TransformExpr(E->getArgument()); 4500 if (Operand.isInvalid()) 4501 return SemaRef.ExprError(); 4502 4503 if (!getDerived().AlwaysRebuild() && 4504 Operand.get() == E->getArgument()) 4505 return SemaRef.Owned(E->Retain()); 4506 4507 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(), 4508 E->isGlobalDelete(), 4509 E->isArrayForm(), 4510 move(Operand)); 4511} 4512 4513template<typename Derived> 4514Sema::OwningExprResult 4515TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( 4516 CXXPseudoDestructorExpr *E, 4517 bool isAddressOfOperand) { 4518 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 4519 if (Base.isInvalid()) 4520 return SemaRef.ExprError(); 4521 4522 NestedNameSpecifier *Qualifier 4523 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 4524 E->getQualifierRange()); 4525 if (E->getQualifier() && !Qualifier) 4526 return SemaRef.ExprError(); 4527 4528 QualType DestroyedType; 4529 { 4530 TemporaryBase Rebase(*this, E->getDestroyedTypeLoc(), DeclarationName()); 4531 DestroyedType = getDerived().TransformType(E->getDestroyedType()); 4532 if (DestroyedType.isNull()) 4533 return SemaRef.ExprError(); 4534 } 4535 4536 if (!getDerived().AlwaysRebuild() && 4537 Base.get() == E->getBase() && 4538 Qualifier == E->getQualifier() && 4539 DestroyedType == E->getDestroyedType()) 4540 return SemaRef.Owned(E->Retain()); 4541 4542 return getDerived().RebuildCXXPseudoDestructorExpr(move(Base), 4543 E->getOperatorLoc(), 4544 E->isArrow(), 4545 E->getDestroyedTypeLoc(), 4546 DestroyedType, 4547 Qualifier, 4548 E->getQualifierRange()); 4549} 4550 4551template<typename Derived> 4552Sema::OwningExprResult 4553TreeTransform<Derived>::TransformUnresolvedLookupExpr( 4554 UnresolvedLookupExpr *E, 4555 bool isAddressOfOperand) { 4556 // There is no transformation we can apply to an unresolved lookup. 4557 return SemaRef.Owned(E->Retain()); 4558} 4559 4560template<typename Derived> 4561Sema::OwningExprResult 4562TreeTransform<Derived>::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr *E, 4563 bool isAddressOfOperand) { 4564 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 4565 4566 QualType T = getDerived().TransformType(E->getQueriedType()); 4567 if (T.isNull()) 4568 return SemaRef.ExprError(); 4569 4570 if (!getDerived().AlwaysRebuild() && 4571 T == E->getQueriedType()) 4572 return SemaRef.Owned(E->Retain()); 4573 4574 // FIXME: Bad location information 4575 SourceLocation FakeLParenLoc 4576 = SemaRef.PP.getLocForEndOfToken(E->getLocStart()); 4577 4578 return getDerived().RebuildUnaryTypeTrait(E->getTrait(), 4579 E->getLocStart(), 4580 /*FIXME:*/FakeLParenLoc, 4581 T, 4582 E->getLocEnd()); 4583} 4584 4585template<typename Derived> 4586Sema::OwningExprResult 4587TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( 4588 DependentScopeDeclRefExpr *E, 4589 bool isAddressOfOperand) { 4590 NestedNameSpecifier *NNS 4591 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 4592 E->getQualifierRange()); 4593 if (!NNS) 4594 return SemaRef.ExprError(); 4595 4596 DeclarationName Name 4597 = getDerived().TransformDeclarationName(E->getDeclName(), E->getLocation()); 4598 if (!Name) 4599 return SemaRef.ExprError(); 4600 4601 if (!getDerived().AlwaysRebuild() && 4602 NNS == E->getQualifier() && 4603 Name == E->getDeclName()) 4604 return SemaRef.Owned(E->Retain()); 4605 4606 return getDerived().RebuildDependentScopeDeclRefExpr(NNS, 4607 E->getQualifierRange(), 4608 Name, 4609 E->getLocation(), 4610 isAddressOfOperand); 4611} 4612 4613template<typename Derived> 4614Sema::OwningExprResult 4615TreeTransform<Derived>::TransformTemplateIdRefExpr(TemplateIdRefExpr *E, 4616 bool isAddressOfOperand) { 4617 TemporaryBase Rebase(*this, E->getTemplateNameLoc(), DeclarationName()); 4618 4619 TemplateName Template 4620 = getDerived().TransformTemplateName(E->getTemplateName()); 4621 if (Template.isNull()) 4622 return SemaRef.ExprError(); 4623 4624 NestedNameSpecifier *Qualifier = 0; 4625 if (E->getQualifier()) { 4626 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 4627 E->getQualifierRange()); 4628 if (!Qualifier) 4629 return SemaRef.ExprError(); 4630 } 4631 4632 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 4633 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 4634 TemplateArgumentLoc Loc; 4635 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc)) 4636 return SemaRef.ExprError(); 4637 TransArgs.addArgument(Loc); 4638 } 4639 4640 // FIXME: Would like to avoid rebuilding if nothing changed, but we can't 4641 // compare template arguments (yet). 4642 4643 // FIXME: It's possible that we'll find out now that the template name 4644 // actually refers to a type, in which case the caller is actually dealing 4645 // with a functional cast. Give a reasonable error message! 4646 return getDerived().RebuildTemplateIdExpr(Qualifier, E->getQualifierRange(), 4647 Template, E->getTemplateNameLoc(), 4648 TransArgs); 4649} 4650 4651template<typename Derived> 4652Sema::OwningExprResult 4653TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E, 4654 bool isAddressOfOperand) { 4655 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 4656 4657 QualType T = getDerived().TransformType(E->getType()); 4658 if (T.isNull()) 4659 return SemaRef.ExprError(); 4660 4661 CXXConstructorDecl *Constructor 4662 = cast_or_null<CXXConstructorDecl>( 4663 getDerived().TransformDecl(E->getConstructor())); 4664 if (!Constructor) 4665 return SemaRef.ExprError(); 4666 4667 bool ArgumentChanged = false; 4668 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 4669 for (CXXConstructExpr::arg_iterator Arg = E->arg_begin(), 4670 ArgEnd = E->arg_end(); 4671 Arg != ArgEnd; ++Arg) { 4672 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 4673 if (TransArg.isInvalid()) 4674 return SemaRef.ExprError(); 4675 4676 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 4677 Args.push_back(TransArg.takeAs<Expr>()); 4678 } 4679 4680 if (!getDerived().AlwaysRebuild() && 4681 T == E->getType() && 4682 Constructor == E->getConstructor() && 4683 !ArgumentChanged) 4684 return SemaRef.Owned(E->Retain()); 4685 4686 return getDerived().RebuildCXXConstructExpr(T, Constructor, E->isElidable(), 4687 move_arg(Args)); 4688} 4689 4690/// \brief Transform a C++ temporary-binding expression. 4691/// 4692/// The transformation of a temporary-binding expression always attempts to 4693/// bind a new temporary variable to its subexpression, even if the 4694/// subexpression itself did not change, because the temporary variable itself 4695/// must be unique. 4696template<typename Derived> 4697Sema::OwningExprResult 4698TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E, 4699 bool isAddressOfOperand) { 4700 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4701 if (SubExpr.isInvalid()) 4702 return SemaRef.ExprError(); 4703 4704 return SemaRef.MaybeBindToTemporary(SubExpr.takeAs<Expr>()); 4705} 4706 4707/// \brief Transform a C++ expression that contains temporaries that should 4708/// be destroyed after the expression is evaluated. 4709/// 4710/// The transformation of a full expression always attempts to build a new 4711/// CXXExprWithTemporaries expression, even if the 4712/// subexpression itself did not change, because it will need to capture the 4713/// the new temporary variables introduced in the subexpression. 4714template<typename Derived> 4715Sema::OwningExprResult 4716TreeTransform<Derived>::TransformCXXExprWithTemporaries( 4717 CXXExprWithTemporaries *E, 4718 bool isAddressOfOperand) { 4719 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4720 if (SubExpr.isInvalid()) 4721 return SemaRef.ExprError(); 4722 4723 return SemaRef.Owned( 4724 SemaRef.MaybeCreateCXXExprWithTemporaries(SubExpr.takeAs<Expr>(), 4725 E->shouldDestroyTemporaries())); 4726} 4727 4728template<typename Derived> 4729Sema::OwningExprResult 4730TreeTransform<Derived>::TransformCXXTemporaryObjectExpr( 4731 CXXTemporaryObjectExpr *E, 4732 bool isAddressOfOperand) { 4733 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 4734 QualType T = getDerived().TransformType(E->getType()); 4735 if (T.isNull()) 4736 return SemaRef.ExprError(); 4737 4738 CXXConstructorDecl *Constructor 4739 = cast_or_null<CXXConstructorDecl>( 4740 getDerived().TransformDecl(E->getConstructor())); 4741 if (!Constructor) 4742 return SemaRef.ExprError(); 4743 4744 bool ArgumentChanged = false; 4745 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 4746 Args.reserve(E->getNumArgs()); 4747 for (CXXTemporaryObjectExpr::arg_iterator Arg = E->arg_begin(), 4748 ArgEnd = E->arg_end(); 4749 Arg != ArgEnd; ++Arg) { 4750 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 4751 if (TransArg.isInvalid()) 4752 return SemaRef.ExprError(); 4753 4754 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 4755 Args.push_back((Expr *)TransArg.release()); 4756 } 4757 4758 if (!getDerived().AlwaysRebuild() && 4759 T == E->getType() && 4760 Constructor == E->getConstructor() && 4761 !ArgumentChanged) 4762 return SemaRef.Owned(E->Retain()); 4763 4764 // FIXME: Bogus location information 4765 SourceLocation CommaLoc; 4766 if (Args.size() > 1) { 4767 Expr *First = (Expr *)Args[0]; 4768 CommaLoc 4769 = SemaRef.PP.getLocForEndOfToken(First->getSourceRange().getEnd()); 4770 } 4771 return getDerived().RebuildCXXTemporaryObjectExpr(E->getTypeBeginLoc(), 4772 T, 4773 /*FIXME:*/E->getTypeBeginLoc(), 4774 move_arg(Args), 4775 &CommaLoc, 4776 E->getLocEnd()); 4777} 4778 4779template<typename Derived> 4780Sema::OwningExprResult 4781TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( 4782 CXXUnresolvedConstructExpr *E, 4783 bool isAddressOfOperand) { 4784 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 4785 QualType T = getDerived().TransformType(E->getTypeAsWritten()); 4786 if (T.isNull()) 4787 return SemaRef.ExprError(); 4788 4789 bool ArgumentChanged = false; 4790 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 4791 llvm::SmallVector<SourceLocation, 8> FakeCommaLocs; 4792 for (CXXUnresolvedConstructExpr::arg_iterator Arg = E->arg_begin(), 4793 ArgEnd = E->arg_end(); 4794 Arg != ArgEnd; ++Arg) { 4795 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 4796 if (TransArg.isInvalid()) 4797 return SemaRef.ExprError(); 4798 4799 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 4800 FakeCommaLocs.push_back( 4801 SemaRef.PP.getLocForEndOfToken((*Arg)->getLocEnd())); 4802 Args.push_back(TransArg.takeAs<Expr>()); 4803 } 4804 4805 if (!getDerived().AlwaysRebuild() && 4806 T == E->getTypeAsWritten() && 4807 !ArgumentChanged) 4808 return SemaRef.Owned(E->Retain()); 4809 4810 // FIXME: we're faking the locations of the commas 4811 return getDerived().RebuildCXXUnresolvedConstructExpr(E->getTypeBeginLoc(), 4812 T, 4813 E->getLParenLoc(), 4814 move_arg(Args), 4815 FakeCommaLocs.data(), 4816 E->getRParenLoc()); 4817} 4818 4819template<typename Derived> 4820Sema::OwningExprResult 4821TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr( 4822 CXXDependentScopeMemberExpr *E, 4823 bool isAddressOfOperand) { 4824 // Transform the base of the expression. 4825 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 4826 if (Base.isInvalid()) 4827 return SemaRef.ExprError(); 4828 4829 // Start the member reference and compute the object's type. 4830 Sema::TypeTy *ObjectType = 0; 4831 Base = SemaRef.ActOnStartCXXMemberReference(0, move(Base), 4832 E->getOperatorLoc(), 4833 E->isArrow()? tok::arrow : tok::period, 4834 ObjectType); 4835 if (Base.isInvalid()) 4836 return SemaRef.ExprError(); 4837 4838 // Transform the first part of the nested-name-specifier that qualifies 4839 // the member name. 4840 NamedDecl *FirstQualifierInScope 4841 = getDerived().TransformFirstQualifierInScope( 4842 E->getFirstQualifierFoundInScope(), 4843 E->getQualifierRange().getBegin()); 4844 4845 NestedNameSpecifier *Qualifier = 0; 4846 if (E->getQualifier()) { 4847 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 4848 E->getQualifierRange(), 4849 QualType::getFromOpaquePtr(ObjectType), 4850 FirstQualifierInScope); 4851 if (!Qualifier) 4852 return SemaRef.ExprError(); 4853 } 4854 4855 DeclarationName Name 4856 = getDerived().TransformDeclarationName(E->getMember(), E->getMemberLoc(), 4857 QualType::getFromOpaquePtr(ObjectType)); 4858 if (!Name) 4859 return SemaRef.ExprError(); 4860 4861 if (!E->hasExplicitTemplateArgumentList()) { 4862 // This is a reference to a member without an explicitly-specified 4863 // template argument list. Optimize for this common case. 4864 if (!getDerived().AlwaysRebuild() && 4865 Base.get() == E->getBase() && 4866 Qualifier == E->getQualifier() && 4867 Name == E->getMember() && 4868 FirstQualifierInScope == E->getFirstQualifierFoundInScope()) 4869 return SemaRef.Owned(E->Retain()); 4870 4871 return getDerived().RebuildCXXDependentScopeMemberExpr(move(Base), 4872 E->isArrow(), 4873 E->getOperatorLoc(), 4874 Qualifier, 4875 E->getQualifierRange(), 4876 Name, 4877 E->getMemberLoc(), 4878 FirstQualifierInScope); 4879 } 4880 4881 // FIXME: This is an ugly hack, which forces the same template name to 4882 // be looked up multiple times. Yuck! 4883 TemporaryBase Rebase(*this, E->getMemberLoc(), DeclarationName()); 4884 TemplateName OrigTemplateName; 4885 if (const IdentifierInfo *II = Name.getAsIdentifierInfo()) 4886 OrigTemplateName = SemaRef.Context.getDependentTemplateName(0, II); 4887 else 4888 OrigTemplateName 4889 = SemaRef.Context.getDependentTemplateName(0, 4890 Name.getCXXOverloadedOperator()); 4891 4892 TemplateName Template 4893 = getDerived().TransformTemplateName(OrigTemplateName, 4894 QualType::getFromOpaquePtr(ObjectType)); 4895 if (Template.isNull()) 4896 return SemaRef.ExprError(); 4897 4898 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 4899 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 4900 TemplateArgumentLoc Loc; 4901 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc)) 4902 return SemaRef.ExprError(); 4903 TransArgs.addArgument(Loc); 4904 } 4905 4906 return getDerived().RebuildCXXDependentScopeMemberExpr(move(Base), 4907 E->isArrow(), 4908 E->getOperatorLoc(), 4909 Qualifier, 4910 E->getQualifierRange(), 4911 Template, 4912 E->getMemberLoc(), 4913 FirstQualifierInScope, 4914 TransArgs); 4915} 4916 4917template<typename Derived> 4918Sema::OwningExprResult 4919TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E, 4920 bool isAddressOfOperand) { 4921 return SemaRef.Owned(E->Retain()); 4922} 4923 4924template<typename Derived> 4925Sema::OwningExprResult 4926TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E, 4927 bool isAddressOfOperand) { 4928 // FIXME: poor source location 4929 TemporaryBase Rebase(*this, E->getAtLoc(), DeclarationName()); 4930 QualType EncodedType = getDerived().TransformType(E->getEncodedType()); 4931 if (EncodedType.isNull()) 4932 return SemaRef.ExprError(); 4933 4934 if (!getDerived().AlwaysRebuild() && 4935 EncodedType == E->getEncodedType()) 4936 return SemaRef.Owned(E->Retain()); 4937 4938 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(), 4939 EncodedType, 4940 E->getRParenLoc()); 4941} 4942 4943template<typename Derived> 4944Sema::OwningExprResult 4945TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E, 4946 bool isAddressOfOperand) { 4947 // FIXME: Implement this! 4948 assert(false && "Cannot transform Objective-C expressions yet"); 4949 return SemaRef.Owned(E->Retain()); 4950} 4951 4952template<typename Derived> 4953Sema::OwningExprResult 4954TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E, 4955 bool isAddressOfOperand) { 4956 return SemaRef.Owned(E->Retain()); 4957} 4958 4959template<typename Derived> 4960Sema::OwningExprResult 4961TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E, 4962 bool isAddressOfOperand) { 4963 ObjCProtocolDecl *Protocol 4964 = cast_or_null<ObjCProtocolDecl>( 4965 getDerived().TransformDecl(E->getProtocol())); 4966 if (!Protocol) 4967 return SemaRef.ExprError(); 4968 4969 if (!getDerived().AlwaysRebuild() && 4970 Protocol == E->getProtocol()) 4971 return SemaRef.Owned(E->Retain()); 4972 4973 return getDerived().RebuildObjCProtocolExpr(Protocol, 4974 E->getAtLoc(), 4975 /*FIXME:*/E->getAtLoc(), 4976 /*FIXME:*/E->getAtLoc(), 4977 E->getRParenLoc()); 4978 4979} 4980 4981template<typename Derived> 4982Sema::OwningExprResult 4983TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E, 4984 bool isAddressOfOperand) { 4985 // FIXME: Implement this! 4986 assert(false && "Cannot transform Objective-C expressions yet"); 4987 return SemaRef.Owned(E->Retain()); 4988} 4989 4990template<typename Derived> 4991Sema::OwningExprResult 4992TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E, 4993 bool isAddressOfOperand) { 4994 // FIXME: Implement this! 4995 assert(false && "Cannot transform Objective-C expressions yet"); 4996 return SemaRef.Owned(E->Retain()); 4997} 4998 4999template<typename Derived> 5000Sema::OwningExprResult 5001TreeTransform<Derived>::TransformObjCImplicitSetterGetterRefExpr( 5002 ObjCImplicitSetterGetterRefExpr *E, 5003 bool isAddressOfOperand) { 5004 // FIXME: Implement this! 5005 assert(false && "Cannot transform Objective-C expressions yet"); 5006 return SemaRef.Owned(E->Retain()); 5007} 5008 5009template<typename Derived> 5010Sema::OwningExprResult 5011TreeTransform<Derived>::TransformObjCSuperExpr(ObjCSuperExpr *E, 5012 bool isAddressOfOperand) { 5013 // FIXME: Implement this! 5014 assert(false && "Cannot transform Objective-C expressions yet"); 5015 return SemaRef.Owned(E->Retain()); 5016} 5017 5018template<typename Derived> 5019Sema::OwningExprResult 5020TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E, 5021 bool isAddressOfOperand) { 5022 // FIXME: Implement this! 5023 assert(false && "Cannot transform Objective-C expressions yet"); 5024 return SemaRef.Owned(E->Retain()); 5025} 5026 5027template<typename Derived> 5028Sema::OwningExprResult 5029TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E, 5030 bool isAddressOfOperand) { 5031 bool ArgumentChanged = false; 5032 ASTOwningVector<&ActionBase::DeleteExpr> SubExprs(SemaRef); 5033 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) { 5034 OwningExprResult SubExpr = getDerived().TransformExpr(E->getExpr(I)); 5035 if (SubExpr.isInvalid()) 5036 return SemaRef.ExprError(); 5037 5038 ArgumentChanged = ArgumentChanged || SubExpr.get() != E->getExpr(I); 5039 SubExprs.push_back(SubExpr.takeAs<Expr>()); 5040 } 5041 5042 if (!getDerived().AlwaysRebuild() && 5043 !ArgumentChanged) 5044 return SemaRef.Owned(E->Retain()); 5045 5046 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(), 5047 move_arg(SubExprs), 5048 E->getRParenLoc()); 5049} 5050 5051template<typename Derived> 5052Sema::OwningExprResult 5053TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E, 5054 bool isAddressOfOperand) { 5055 // FIXME: Implement this! 5056 assert(false && "Cannot transform block expressions yet"); 5057 return SemaRef.Owned(E->Retain()); 5058} 5059 5060template<typename Derived> 5061Sema::OwningExprResult 5062TreeTransform<Derived>::TransformBlockDeclRefExpr(BlockDeclRefExpr *E, 5063 bool isAddressOfOperand) { 5064 // FIXME: Implement this! 5065 assert(false && "Cannot transform block-related expressions yet"); 5066 return SemaRef.Owned(E->Retain()); 5067} 5068 5069//===----------------------------------------------------------------------===// 5070// Type reconstruction 5071//===----------------------------------------------------------------------===// 5072 5073template<typename Derived> 5074QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType, 5075 SourceLocation Star) { 5076 return SemaRef.BuildPointerType(PointeeType, Qualifiers(), Star, 5077 getDerived().getBaseEntity()); 5078} 5079 5080template<typename Derived> 5081QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType, 5082 SourceLocation Star) { 5083 return SemaRef.BuildBlockPointerType(PointeeType, Qualifiers(), Star, 5084 getDerived().getBaseEntity()); 5085} 5086 5087template<typename Derived> 5088QualType 5089TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType, 5090 bool WrittenAsLValue, 5091 SourceLocation Sigil) { 5092 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue, Qualifiers(), 5093 Sigil, getDerived().getBaseEntity()); 5094} 5095 5096template<typename Derived> 5097QualType 5098TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType, 5099 QualType ClassType, 5100 SourceLocation Sigil) { 5101 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Qualifiers(), 5102 Sigil, getDerived().getBaseEntity()); 5103} 5104 5105template<typename Derived> 5106QualType 5107TreeTransform<Derived>::RebuildObjCObjectPointerType(QualType PointeeType, 5108 SourceLocation Sigil) { 5109 return SemaRef.BuildPointerType(PointeeType, Qualifiers(), Sigil, 5110 getDerived().getBaseEntity()); 5111} 5112 5113template<typename Derived> 5114QualType 5115TreeTransform<Derived>::RebuildArrayType(QualType ElementType, 5116 ArrayType::ArraySizeModifier SizeMod, 5117 const llvm::APInt *Size, 5118 Expr *SizeExpr, 5119 unsigned IndexTypeQuals, 5120 SourceRange BracketsRange) { 5121 if (SizeExpr || !Size) 5122 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr, 5123 IndexTypeQuals, BracketsRange, 5124 getDerived().getBaseEntity()); 5125 5126 QualType Types[] = { 5127 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy, 5128 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, 5129 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty 5130 }; 5131 const unsigned NumTypes = sizeof(Types) / sizeof(QualType); 5132 QualType SizeType; 5133 for (unsigned I = 0; I != NumTypes; ++I) 5134 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) { 5135 SizeType = Types[I]; 5136 break; 5137 } 5138 5139 if (SizeType.isNull()) 5140 SizeType = SemaRef.Context.getFixedWidthIntType(Size->getBitWidth(), false); 5141 5142 IntegerLiteral ArraySize(*Size, SizeType, /*FIXME*/BracketsRange.getBegin()); 5143 return SemaRef.BuildArrayType(ElementType, SizeMod, &ArraySize, 5144 IndexTypeQuals, BracketsRange, 5145 getDerived().getBaseEntity()); 5146} 5147 5148template<typename Derived> 5149QualType 5150TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType, 5151 ArrayType::ArraySizeModifier SizeMod, 5152 const llvm::APInt &Size, 5153 unsigned IndexTypeQuals, 5154 SourceRange BracketsRange) { 5155 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0, 5156 IndexTypeQuals, BracketsRange); 5157} 5158 5159template<typename Derived> 5160QualType 5161TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType, 5162 ArrayType::ArraySizeModifier SizeMod, 5163 unsigned IndexTypeQuals, 5164 SourceRange BracketsRange) { 5165 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 0, 5166 IndexTypeQuals, BracketsRange); 5167} 5168 5169template<typename Derived> 5170QualType 5171TreeTransform<Derived>::RebuildVariableArrayType(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 5183TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType, 5184 ArrayType::ArraySizeModifier SizeMod, 5185 ExprArg SizeExpr, 5186 unsigned IndexTypeQuals, 5187 SourceRange BracketsRange) { 5188 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 5189 SizeExpr.takeAs<Expr>(), 5190 IndexTypeQuals, BracketsRange); 5191} 5192 5193template<typename Derived> 5194QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType, 5195 unsigned NumElements) { 5196 // FIXME: semantic checking! 5197 return SemaRef.Context.getVectorType(ElementType, NumElements); 5198} 5199 5200template<typename Derived> 5201QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType, 5202 unsigned NumElements, 5203 SourceLocation AttributeLoc) { 5204 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy), 5205 NumElements, true); 5206 IntegerLiteral *VectorSize 5207 = new (SemaRef.Context) IntegerLiteral(numElements, SemaRef.Context.IntTy, 5208 AttributeLoc); 5209 return SemaRef.BuildExtVectorType(ElementType, SemaRef.Owned(VectorSize), 5210 AttributeLoc); 5211} 5212 5213template<typename Derived> 5214QualType 5215TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType, 5216 ExprArg SizeExpr, 5217 SourceLocation AttributeLoc) { 5218 return SemaRef.BuildExtVectorType(ElementType, move(SizeExpr), AttributeLoc); 5219} 5220 5221template<typename Derived> 5222QualType TreeTransform<Derived>::RebuildFunctionProtoType(QualType T, 5223 QualType *ParamTypes, 5224 unsigned NumParamTypes, 5225 bool Variadic, 5226 unsigned Quals) { 5227 return SemaRef.BuildFunctionType(T, ParamTypes, NumParamTypes, Variadic, 5228 Quals, 5229 getDerived().getBaseLocation(), 5230 getDerived().getBaseEntity()); 5231} 5232 5233template<typename Derived> 5234QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) { 5235 return SemaRef.Context.getFunctionNoProtoType(T); 5236} 5237 5238template<typename Derived> 5239QualType TreeTransform<Derived>::RebuildTypeOfExprType(ExprArg E) { 5240 return SemaRef.BuildTypeofExprType(E.takeAs<Expr>()); 5241} 5242 5243template<typename Derived> 5244QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) { 5245 return SemaRef.Context.getTypeOfType(Underlying); 5246} 5247 5248template<typename Derived> 5249QualType TreeTransform<Derived>::RebuildDecltypeType(ExprArg E) { 5250 return SemaRef.BuildDecltypeType(E.takeAs<Expr>()); 5251} 5252 5253template<typename Derived> 5254QualType TreeTransform<Derived>::RebuildTemplateSpecializationType( 5255 TemplateName Template, 5256 SourceLocation TemplateNameLoc, 5257 const TemplateArgumentListInfo &TemplateArgs) { 5258 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs); 5259} 5260 5261template<typename Derived> 5262NestedNameSpecifier * 5263TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 5264 SourceRange Range, 5265 IdentifierInfo &II, 5266 QualType ObjectType, 5267 NamedDecl *FirstQualifierInScope) { 5268 CXXScopeSpec SS; 5269 // FIXME: The source location information is all wrong. 5270 SS.setRange(Range); 5271 SS.setScopeRep(Prefix); 5272 return static_cast<NestedNameSpecifier *>( 5273 SemaRef.BuildCXXNestedNameSpecifier(0, SS, Range.getEnd(), 5274 Range.getEnd(), II, 5275 ObjectType, 5276 FirstQualifierInScope, 5277 false)); 5278} 5279 5280template<typename Derived> 5281NestedNameSpecifier * 5282TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 5283 SourceRange Range, 5284 NamespaceDecl *NS) { 5285 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, NS); 5286} 5287 5288template<typename Derived> 5289NestedNameSpecifier * 5290TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 5291 SourceRange Range, 5292 bool TemplateKW, 5293 QualType T) { 5294 if (T->isDependentType() || T->isRecordType() || 5295 (SemaRef.getLangOptions().CPlusPlus0x && T->isEnumeralType())) { 5296 assert(!T.hasLocalQualifiers() && "Can't get cv-qualifiers here"); 5297 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, TemplateKW, 5298 T.getTypePtr()); 5299 } 5300 5301 SemaRef.Diag(Range.getBegin(), diag::err_nested_name_spec_non_tag) << T; 5302 return 0; 5303} 5304 5305template<typename Derived> 5306TemplateName 5307TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5308 bool TemplateKW, 5309 TemplateDecl *Template) { 5310 return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW, 5311 Template); 5312} 5313 5314template<typename Derived> 5315TemplateName 5316TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5317 bool TemplateKW, 5318 OverloadedFunctionDecl *Ovl) { 5319 return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW, Ovl); 5320} 5321 5322template<typename Derived> 5323TemplateName 5324TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5325 const IdentifierInfo &II, 5326 QualType ObjectType) { 5327 CXXScopeSpec SS; 5328 SS.setRange(SourceRange(getDerived().getBaseLocation())); 5329 SS.setScopeRep(Qualifier); 5330 UnqualifiedId Name; 5331 Name.setIdentifier(&II, /*FIXME:*/getDerived().getBaseLocation()); 5332 return getSema().ActOnDependentTemplateName( 5333 /*FIXME:*/getDerived().getBaseLocation(), 5334 SS, 5335 Name, 5336 ObjectType.getAsOpaquePtr(), 5337 /*EnteringContext=*/false) 5338 .template getAsVal<TemplateName>(); 5339} 5340 5341template<typename Derived> 5342TemplateName 5343TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5344 OverloadedOperatorKind Operator, 5345 QualType ObjectType) { 5346 CXXScopeSpec SS; 5347 SS.setRange(SourceRange(getDerived().getBaseLocation())); 5348 SS.setScopeRep(Qualifier); 5349 UnqualifiedId Name; 5350 SourceLocation SymbolLocations[3]; // FIXME: Bogus location information. 5351 Name.setOperatorFunctionId(/*FIXME:*/getDerived().getBaseLocation(), 5352 Operator, SymbolLocations); 5353 return getSema().ActOnDependentTemplateName( 5354 /*FIXME:*/getDerived().getBaseLocation(), 5355 SS, 5356 Name, 5357 ObjectType.getAsOpaquePtr(), 5358 /*EnteringContext=*/false) 5359 .template getAsVal<TemplateName>(); 5360} 5361 5362template<typename Derived> 5363Sema::OwningExprResult 5364TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, 5365 SourceLocation OpLoc, 5366 ExprArg Callee, 5367 ExprArg First, 5368 ExprArg Second) { 5369 Expr *FirstExpr = (Expr *)First.get(); 5370 Expr *SecondExpr = (Expr *)Second.get(); 5371 Expr *CalleeExpr = ((Expr *)Callee.get())->IgnoreParenCasts(); 5372 bool isPostIncDec = SecondExpr && (Op == OO_PlusPlus || Op == OO_MinusMinus); 5373 5374 // Determine whether this should be a builtin operation. 5375 if (Op == OO_Subscript) { 5376 if (!FirstExpr->getType()->isOverloadableType() && 5377 !SecondExpr->getType()->isOverloadableType()) 5378 return getSema().CreateBuiltinArraySubscriptExpr(move(First), 5379 CalleeExpr->getLocStart(), 5380 move(Second), OpLoc); 5381 } else if (Op == OO_Arrow) { 5382 // -> is never a builtin operation. 5383 return SemaRef.BuildOverloadedArrowExpr(0, move(First), OpLoc); 5384 } else if (SecondExpr == 0 || isPostIncDec) { 5385 if (!FirstExpr->getType()->isOverloadableType()) { 5386 // The argument is not of overloadable type, so try to create a 5387 // built-in unary operation. 5388 UnaryOperator::Opcode Opc 5389 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 5390 5391 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, move(First)); 5392 } 5393 } else { 5394 if (!FirstExpr->getType()->isOverloadableType() && 5395 !SecondExpr->getType()->isOverloadableType()) { 5396 // Neither of the arguments is an overloadable type, so try to 5397 // create a built-in binary operation. 5398 BinaryOperator::Opcode Opc = BinaryOperator::getOverloadedOpcode(Op); 5399 OwningExprResult Result 5400 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, FirstExpr, SecondExpr); 5401 if (Result.isInvalid()) 5402 return SemaRef.ExprError(); 5403 5404 First.release(); 5405 Second.release(); 5406 return move(Result); 5407 } 5408 } 5409 5410 // Compute the transformed set of functions (and function templates) to be 5411 // used during overload resolution. 5412 Sema::FunctionSet Functions; 5413 5414 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(CalleeExpr)) { 5415 assert(ULE->requiresADL()); 5416 5417 // FIXME: Do we have to check 5418 // IsAcceptableNonMemberOperatorCandidate for each of these? 5419 for (UnresolvedLookupExpr::decls_iterator I = ULE->decls_begin(), 5420 E = ULE->decls_end(); I != E; ++I) 5421 Functions.insert(AnyFunctionDecl::getFromNamedDecl(*I)); 5422 } else { 5423 Functions.insert(AnyFunctionDecl::getFromNamedDecl( 5424 cast<DeclRefExpr>(CalleeExpr)->getDecl())); 5425 } 5426 5427 // Add any functions found via argument-dependent lookup. 5428 Expr *Args[2] = { FirstExpr, SecondExpr }; 5429 unsigned NumArgs = 1 + (SecondExpr != 0); 5430 DeclarationName OpName 5431 = SemaRef.Context.DeclarationNames.getCXXOperatorName(Op); 5432 SemaRef.ArgumentDependentLookup(OpName, /*Operator*/true, Args, NumArgs, 5433 Functions); 5434 5435 // Create the overloaded operator invocation for unary operators. 5436 if (NumArgs == 1 || isPostIncDec) { 5437 UnaryOperator::Opcode Opc 5438 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 5439 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, move(First)); 5440 } 5441 5442 if (Op == OO_Subscript) 5443 return SemaRef.CreateOverloadedArraySubscriptExpr(CalleeExpr->getLocStart(), 5444 OpLoc, 5445 move(First), 5446 move(Second)); 5447 5448 // Create the overloaded operator invocation for binary operators. 5449 BinaryOperator::Opcode Opc = 5450 BinaryOperator::getOverloadedOpcode(Op); 5451 OwningExprResult Result 5452 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]); 5453 if (Result.isInvalid()) 5454 return SemaRef.ExprError(); 5455 5456 First.release(); 5457 Second.release(); 5458 return move(Result); 5459} 5460 5461} // end namespace clang 5462 5463#endif // LLVM_CLANG_SEMA_TREETRANSFORM_H 5464