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