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