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