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