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