TreeTransform.h revision 3cb0ebd5f76abcb776f7cb4062bd79e3268c0dc4
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, Qualifier, 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 2826template<typename Derived> 2827QualType TreeTransform<Derived>::TransformInjectedClassNameType( 2828 TypeLocBuilder &TLB, 2829 InjectedClassNameTypeLoc TL, 2830 QualType ObjectType) { 2831 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), 2832 TL.getTypePtr()->getDecl()); 2833 if (!D) return QualType(); 2834 2835 QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D)); 2836 TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc()); 2837 return T; 2838} 2839 2840 2841template<typename Derived> 2842QualType TreeTransform<Derived>::TransformTemplateTypeParmType( 2843 TypeLocBuilder &TLB, 2844 TemplateTypeParmTypeLoc TL, 2845 QualType ObjectType) { 2846 return TransformTypeSpecType(TLB, TL); 2847} 2848 2849template<typename Derived> 2850QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType( 2851 TypeLocBuilder &TLB, 2852 SubstTemplateTypeParmTypeLoc TL, 2853 QualType ObjectType) { 2854 return TransformTypeSpecType(TLB, TL); 2855} 2856 2857template<typename Derived> 2858QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 2859 const TemplateSpecializationType *TST, 2860 QualType ObjectType) { 2861 // FIXME: this entire method is a temporary workaround; callers 2862 // should be rewritten to provide real type locs. 2863 2864 // Fake up a TemplateSpecializationTypeLoc. 2865 TypeLocBuilder TLB; 2866 TemplateSpecializationTypeLoc TL 2867 = TLB.push<TemplateSpecializationTypeLoc>(QualType(TST, 0)); 2868 2869 SourceLocation BaseLoc = getDerived().getBaseLocation(); 2870 2871 TL.setTemplateNameLoc(BaseLoc); 2872 TL.setLAngleLoc(BaseLoc); 2873 TL.setRAngleLoc(BaseLoc); 2874 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 2875 const TemplateArgument &TA = TST->getArg(i); 2876 TemplateArgumentLoc TAL; 2877 getDerived().InventTemplateArgumentLoc(TA, TAL); 2878 TL.setArgLocInfo(i, TAL.getLocInfo()); 2879 } 2880 2881 TypeLocBuilder IgnoredTLB; 2882 return TransformTemplateSpecializationType(IgnoredTLB, TL, ObjectType); 2883} 2884 2885template<typename Derived> 2886QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 2887 TypeLocBuilder &TLB, 2888 TemplateSpecializationTypeLoc TL, 2889 QualType ObjectType) { 2890 const TemplateSpecializationType *T = TL.getTypePtr(); 2891 2892 TemplateName Template 2893 = getDerived().TransformTemplateName(T->getTemplateName(), ObjectType); 2894 if (Template.isNull()) 2895 return QualType(); 2896 2897 TemplateArgumentListInfo NewTemplateArgs; 2898 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 2899 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 2900 2901 for (unsigned i = 0, e = T->getNumArgs(); i != e; ++i) { 2902 TemplateArgumentLoc Loc; 2903 if (getDerived().TransformTemplateArgument(TL.getArgLoc(i), Loc)) 2904 return QualType(); 2905 NewTemplateArgs.addArgument(Loc); 2906 } 2907 2908 // FIXME: maybe don't rebuild if all the template arguments are the same. 2909 2910 QualType Result = 2911 getDerived().RebuildTemplateSpecializationType(Template, 2912 TL.getTemplateNameLoc(), 2913 NewTemplateArgs); 2914 2915 if (!Result.isNull()) { 2916 TemplateSpecializationTypeLoc NewTL 2917 = TLB.push<TemplateSpecializationTypeLoc>(Result); 2918 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 2919 NewTL.setLAngleLoc(TL.getLAngleLoc()); 2920 NewTL.setRAngleLoc(TL.getRAngleLoc()); 2921 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 2922 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 2923 } 2924 2925 return Result; 2926} 2927 2928template<typename Derived> 2929QualType 2930TreeTransform<Derived>::TransformQualifiedNameType(TypeLocBuilder &TLB, 2931 QualifiedNameTypeLoc TL, 2932 QualType ObjectType) { 2933 QualifiedNameType *T = TL.getTypePtr(); 2934 NestedNameSpecifier *NNS 2935 = getDerived().TransformNestedNameSpecifier(T->getQualifier(), 2936 SourceRange(), 2937 ObjectType); 2938 if (!NNS) 2939 return QualType(); 2940 2941 QualType Named = getDerived().TransformType(T->getNamedType()); 2942 if (Named.isNull()) 2943 return QualType(); 2944 2945 QualType Result = TL.getType(); 2946 if (getDerived().AlwaysRebuild() || 2947 NNS != T->getQualifier() || 2948 Named != T->getNamedType()) { 2949 Result = getDerived().RebuildQualifiedNameType(NNS, Named); 2950 if (Result.isNull()) 2951 return QualType(); 2952 } 2953 2954 QualifiedNameTypeLoc NewTL = TLB.push<QualifiedNameTypeLoc>(Result); 2955 NewTL.setNameLoc(TL.getNameLoc()); 2956 2957 return Result; 2958} 2959 2960template<typename Derived> 2961QualType TreeTransform<Derived>::TransformTypenameType(TypeLocBuilder &TLB, 2962 TypenameTypeLoc TL, 2963 QualType ObjectType) { 2964 TypenameType *T = TL.getTypePtr(); 2965 2966 /* FIXME: preserve source information better than this */ 2967 SourceRange SR(TL.getNameLoc()); 2968 2969 NestedNameSpecifier *NNS 2970 = getDerived().TransformNestedNameSpecifier(T->getQualifier(), SR, 2971 ObjectType); 2972 if (!NNS) 2973 return QualType(); 2974 2975 QualType Result; 2976 2977 if (const TemplateSpecializationType *TemplateId = T->getTemplateId()) { 2978 QualType NewTemplateId 2979 = getDerived().TransformType(QualType(TemplateId, 0)); 2980 if (NewTemplateId.isNull()) 2981 return QualType(); 2982 2983 if (!getDerived().AlwaysRebuild() && 2984 NNS == T->getQualifier() && 2985 NewTemplateId == QualType(TemplateId, 0)) 2986 return QualType(T, 0); 2987 2988 Result = getDerived().RebuildTypenameType(NNS, NewTemplateId); 2989 } else { 2990 Result = getDerived().RebuildTypenameType(NNS, T->getIdentifier(), SR); 2991 } 2992 if (Result.isNull()) 2993 return QualType(); 2994 2995 TypenameTypeLoc NewTL = TLB.push<TypenameTypeLoc>(Result); 2996 NewTL.setNameLoc(TL.getNameLoc()); 2997 2998 return Result; 2999} 3000 3001template<typename Derived> 3002QualType 3003TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB, 3004 ObjCInterfaceTypeLoc TL, 3005 QualType ObjectType) { 3006 assert(false && "TransformObjCInterfaceType unimplemented"); 3007 return QualType(); 3008} 3009 3010template<typename Derived> 3011QualType 3012TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB, 3013 ObjCObjectPointerTypeLoc TL, 3014 QualType ObjectType) { 3015 assert(false && "TransformObjCObjectPointerType unimplemented"); 3016 return QualType(); 3017} 3018 3019//===----------------------------------------------------------------------===// 3020// Statement transformation 3021//===----------------------------------------------------------------------===// 3022template<typename Derived> 3023Sema::OwningStmtResult 3024TreeTransform<Derived>::TransformNullStmt(NullStmt *S) { 3025 return SemaRef.Owned(S->Retain()); 3026} 3027 3028template<typename Derived> 3029Sema::OwningStmtResult 3030TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) { 3031 return getDerived().TransformCompoundStmt(S, false); 3032} 3033 3034template<typename Derived> 3035Sema::OwningStmtResult 3036TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S, 3037 bool IsStmtExpr) { 3038 bool SubStmtChanged = false; 3039 ASTOwningVector<&ActionBase::DeleteStmt> Statements(getSema()); 3040 for (CompoundStmt::body_iterator B = S->body_begin(), BEnd = S->body_end(); 3041 B != BEnd; ++B) { 3042 OwningStmtResult Result = getDerived().TransformStmt(*B); 3043 if (Result.isInvalid()) 3044 return getSema().StmtError(); 3045 3046 SubStmtChanged = SubStmtChanged || Result.get() != *B; 3047 Statements.push_back(Result.takeAs<Stmt>()); 3048 } 3049 3050 if (!getDerived().AlwaysRebuild() && 3051 !SubStmtChanged) 3052 return SemaRef.Owned(S->Retain()); 3053 3054 return getDerived().RebuildCompoundStmt(S->getLBracLoc(), 3055 move_arg(Statements), 3056 S->getRBracLoc(), 3057 IsStmtExpr); 3058} 3059 3060template<typename Derived> 3061Sema::OwningStmtResult 3062TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) { 3063 OwningExprResult LHS(SemaRef), RHS(SemaRef); 3064 { 3065 // The case value expressions are not potentially evaluated. 3066 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 3067 3068 // Transform the left-hand case value. 3069 LHS = getDerived().TransformExpr(S->getLHS()); 3070 if (LHS.isInvalid()) 3071 return SemaRef.StmtError(); 3072 3073 // Transform the right-hand case value (for the GNU case-range extension). 3074 RHS = getDerived().TransformExpr(S->getRHS()); 3075 if (RHS.isInvalid()) 3076 return SemaRef.StmtError(); 3077 } 3078 3079 // Build the case statement. 3080 // Case statements are always rebuilt so that they will attached to their 3081 // transformed switch statement. 3082 OwningStmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(), 3083 move(LHS), 3084 S->getEllipsisLoc(), 3085 move(RHS), 3086 S->getColonLoc()); 3087 if (Case.isInvalid()) 3088 return SemaRef.StmtError(); 3089 3090 // Transform the statement following the case 3091 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 3092 if (SubStmt.isInvalid()) 3093 return SemaRef.StmtError(); 3094 3095 // Attach the body to the case statement 3096 return getDerived().RebuildCaseStmtBody(move(Case), move(SubStmt)); 3097} 3098 3099template<typename Derived> 3100Sema::OwningStmtResult 3101TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) { 3102 // Transform the statement following the default case 3103 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 3104 if (SubStmt.isInvalid()) 3105 return SemaRef.StmtError(); 3106 3107 // Default statements are always rebuilt 3108 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(), 3109 move(SubStmt)); 3110} 3111 3112template<typename Derived> 3113Sema::OwningStmtResult 3114TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) { 3115 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 3116 if (SubStmt.isInvalid()) 3117 return SemaRef.StmtError(); 3118 3119 // FIXME: Pass the real colon location in. 3120 SourceLocation ColonLoc = SemaRef.PP.getLocForEndOfToken(S->getIdentLoc()); 3121 return getDerived().RebuildLabelStmt(S->getIdentLoc(), S->getID(), ColonLoc, 3122 move(SubStmt)); 3123} 3124 3125template<typename Derived> 3126Sema::OwningStmtResult 3127TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { 3128 // Transform the condition 3129 OwningExprResult Cond(SemaRef); 3130 VarDecl *ConditionVar = 0; 3131 if (S->getConditionVariable()) { 3132 ConditionVar 3133 = cast_or_null<VarDecl>( 3134 getDerived().TransformDefinition( 3135 S->getConditionVariable()->getLocation(), 3136 S->getConditionVariable())); 3137 if (!ConditionVar) 3138 return SemaRef.StmtError(); 3139 } else { 3140 Cond = getDerived().TransformExpr(S->getCond()); 3141 3142 if (Cond.isInvalid()) 3143 return SemaRef.StmtError(); 3144 } 3145 3146 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond)); 3147 3148 // Transform the "then" branch. 3149 OwningStmtResult Then = getDerived().TransformStmt(S->getThen()); 3150 if (Then.isInvalid()) 3151 return SemaRef.StmtError(); 3152 3153 // Transform the "else" branch. 3154 OwningStmtResult Else = getDerived().TransformStmt(S->getElse()); 3155 if (Else.isInvalid()) 3156 return SemaRef.StmtError(); 3157 3158 if (!getDerived().AlwaysRebuild() && 3159 FullCond->get() == S->getCond() && 3160 ConditionVar == S->getConditionVariable() && 3161 Then.get() == S->getThen() && 3162 Else.get() == S->getElse()) 3163 return SemaRef.Owned(S->Retain()); 3164 3165 return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, ConditionVar, 3166 move(Then), 3167 S->getElseLoc(), move(Else)); 3168} 3169 3170template<typename Derived> 3171Sema::OwningStmtResult 3172TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) { 3173 // Transform the condition. 3174 OwningExprResult Cond(SemaRef); 3175 VarDecl *ConditionVar = 0; 3176 if (S->getConditionVariable()) { 3177 ConditionVar 3178 = cast_or_null<VarDecl>( 3179 getDerived().TransformDefinition( 3180 S->getConditionVariable()->getLocation(), 3181 S->getConditionVariable())); 3182 if (!ConditionVar) 3183 return SemaRef.StmtError(); 3184 } else { 3185 Cond = getDerived().TransformExpr(S->getCond()); 3186 3187 if (Cond.isInvalid()) 3188 return SemaRef.StmtError(); 3189 } 3190 3191 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond)); 3192 3193 // Rebuild the switch statement. 3194 OwningStmtResult Switch = getDerived().RebuildSwitchStmtStart(FullCond, 3195 ConditionVar); 3196 if (Switch.isInvalid()) 3197 return SemaRef.StmtError(); 3198 3199 // Transform the body of the switch statement. 3200 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3201 if (Body.isInvalid()) 3202 return SemaRef.StmtError(); 3203 3204 // Complete the switch statement. 3205 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), move(Switch), 3206 move(Body)); 3207} 3208 3209template<typename Derived> 3210Sema::OwningStmtResult 3211TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) { 3212 // Transform the condition 3213 OwningExprResult Cond(SemaRef); 3214 VarDecl *ConditionVar = 0; 3215 if (S->getConditionVariable()) { 3216 ConditionVar 3217 = cast_or_null<VarDecl>( 3218 getDerived().TransformDefinition( 3219 S->getConditionVariable()->getLocation(), 3220 S->getConditionVariable())); 3221 if (!ConditionVar) 3222 return SemaRef.StmtError(); 3223 } else { 3224 Cond = getDerived().TransformExpr(S->getCond()); 3225 3226 if (Cond.isInvalid()) 3227 return SemaRef.StmtError(); 3228 } 3229 3230 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond)); 3231 3232 // Transform the body 3233 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3234 if (Body.isInvalid()) 3235 return SemaRef.StmtError(); 3236 3237 if (!getDerived().AlwaysRebuild() && 3238 FullCond->get() == S->getCond() && 3239 ConditionVar == S->getConditionVariable() && 3240 Body.get() == S->getBody()) 3241 return SemaRef.Owned(S->Retain()); 3242 3243 return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond, ConditionVar, 3244 move(Body)); 3245} 3246 3247template<typename Derived> 3248Sema::OwningStmtResult 3249TreeTransform<Derived>::TransformDoStmt(DoStmt *S) { 3250 // Transform the condition 3251 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 3252 if (Cond.isInvalid()) 3253 return SemaRef.StmtError(); 3254 3255 // Transform the body 3256 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3257 if (Body.isInvalid()) 3258 return SemaRef.StmtError(); 3259 3260 if (!getDerived().AlwaysRebuild() && 3261 Cond.get() == S->getCond() && 3262 Body.get() == S->getBody()) 3263 return SemaRef.Owned(S->Retain()); 3264 3265 return getDerived().RebuildDoStmt(S->getDoLoc(), move(Body), S->getWhileLoc(), 3266 /*FIXME:*/S->getWhileLoc(), move(Cond), 3267 S->getRParenLoc()); 3268} 3269 3270template<typename Derived> 3271Sema::OwningStmtResult 3272TreeTransform<Derived>::TransformForStmt(ForStmt *S) { 3273 // Transform the initialization statement 3274 OwningStmtResult Init = getDerived().TransformStmt(S->getInit()); 3275 if (Init.isInvalid()) 3276 return SemaRef.StmtError(); 3277 3278 // Transform the condition 3279 OwningExprResult Cond(SemaRef); 3280 VarDecl *ConditionVar = 0; 3281 if (S->getConditionVariable()) { 3282 ConditionVar 3283 = cast_or_null<VarDecl>( 3284 getDerived().TransformDefinition( 3285 S->getConditionVariable()->getLocation(), 3286 S->getConditionVariable())); 3287 if (!ConditionVar) 3288 return SemaRef.StmtError(); 3289 } else { 3290 Cond = getDerived().TransformExpr(S->getCond()); 3291 3292 if (Cond.isInvalid()) 3293 return SemaRef.StmtError(); 3294 } 3295 3296 // Transform the increment 3297 OwningExprResult Inc = getDerived().TransformExpr(S->getInc()); 3298 if (Inc.isInvalid()) 3299 return SemaRef.StmtError(); 3300 3301 // Transform the body 3302 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3303 if (Body.isInvalid()) 3304 return SemaRef.StmtError(); 3305 3306 if (!getDerived().AlwaysRebuild() && 3307 Init.get() == S->getInit() && 3308 Cond.get() == S->getCond() && 3309 Inc.get() == S->getInc() && 3310 Body.get() == S->getBody()) 3311 return SemaRef.Owned(S->Retain()); 3312 3313 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(), 3314 move(Init), getSema().MakeFullExpr(Cond), 3315 ConditionVar, 3316 getSema().MakeFullExpr(Inc), 3317 S->getRParenLoc(), move(Body)); 3318} 3319 3320template<typename Derived> 3321Sema::OwningStmtResult 3322TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) { 3323 // Goto statements must always be rebuilt, to resolve the label. 3324 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(), 3325 S->getLabel()); 3326} 3327 3328template<typename Derived> 3329Sema::OwningStmtResult 3330TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) { 3331 OwningExprResult Target = getDerived().TransformExpr(S->getTarget()); 3332 if (Target.isInvalid()) 3333 return SemaRef.StmtError(); 3334 3335 if (!getDerived().AlwaysRebuild() && 3336 Target.get() == S->getTarget()) 3337 return SemaRef.Owned(S->Retain()); 3338 3339 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(), 3340 move(Target)); 3341} 3342 3343template<typename Derived> 3344Sema::OwningStmtResult 3345TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) { 3346 return SemaRef.Owned(S->Retain()); 3347} 3348 3349template<typename Derived> 3350Sema::OwningStmtResult 3351TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) { 3352 return SemaRef.Owned(S->Retain()); 3353} 3354 3355template<typename Derived> 3356Sema::OwningStmtResult 3357TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) { 3358 Sema::OwningExprResult Result = getDerived().TransformExpr(S->getRetValue()); 3359 if (Result.isInvalid()) 3360 return SemaRef.StmtError(); 3361 3362 // FIXME: We always rebuild the return statement because there is no way 3363 // to tell whether the return type of the function has changed. 3364 return getDerived().RebuildReturnStmt(S->getReturnLoc(), move(Result)); 3365} 3366 3367template<typename Derived> 3368Sema::OwningStmtResult 3369TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) { 3370 bool DeclChanged = false; 3371 llvm::SmallVector<Decl *, 4> Decls; 3372 for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end(); 3373 D != DEnd; ++D) { 3374 Decl *Transformed = getDerived().TransformDefinition((*D)->getLocation(), 3375 *D); 3376 if (!Transformed) 3377 return SemaRef.StmtError(); 3378 3379 if (Transformed != *D) 3380 DeclChanged = true; 3381 3382 Decls.push_back(Transformed); 3383 } 3384 3385 if (!getDerived().AlwaysRebuild() && !DeclChanged) 3386 return SemaRef.Owned(S->Retain()); 3387 3388 return getDerived().RebuildDeclStmt(Decls.data(), Decls.size(), 3389 S->getStartLoc(), S->getEndLoc()); 3390} 3391 3392template<typename Derived> 3393Sema::OwningStmtResult 3394TreeTransform<Derived>::TransformSwitchCase(SwitchCase *S) { 3395 assert(false && "SwitchCase is abstract and cannot be transformed"); 3396 return SemaRef.Owned(S->Retain()); 3397} 3398 3399template<typename Derived> 3400Sema::OwningStmtResult 3401TreeTransform<Derived>::TransformAsmStmt(AsmStmt *S) { 3402 3403 ASTOwningVector<&ActionBase::DeleteExpr> Constraints(getSema()); 3404 ASTOwningVector<&ActionBase::DeleteExpr> Exprs(getSema()); 3405 llvm::SmallVector<IdentifierInfo *, 4> Names; 3406 3407 OwningExprResult AsmString(SemaRef); 3408 ASTOwningVector<&ActionBase::DeleteExpr> Clobbers(getSema()); 3409 3410 bool ExprsChanged = false; 3411 3412 // Go through the outputs. 3413 for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) { 3414 Names.push_back(S->getOutputIdentifier(I)); 3415 3416 // No need to transform the constraint literal. 3417 Constraints.push_back(S->getOutputConstraintLiteral(I)->Retain()); 3418 3419 // Transform the output expr. 3420 Expr *OutputExpr = S->getOutputExpr(I); 3421 OwningExprResult Result = getDerived().TransformExpr(OutputExpr); 3422 if (Result.isInvalid()) 3423 return SemaRef.StmtError(); 3424 3425 ExprsChanged |= Result.get() != OutputExpr; 3426 3427 Exprs.push_back(Result.takeAs<Expr>()); 3428 } 3429 3430 // Go through the inputs. 3431 for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) { 3432 Names.push_back(S->getInputIdentifier(I)); 3433 3434 // No need to transform the constraint literal. 3435 Constraints.push_back(S->getInputConstraintLiteral(I)->Retain()); 3436 3437 // Transform the input expr. 3438 Expr *InputExpr = S->getInputExpr(I); 3439 OwningExprResult Result = getDerived().TransformExpr(InputExpr); 3440 if (Result.isInvalid()) 3441 return SemaRef.StmtError(); 3442 3443 ExprsChanged |= Result.get() != InputExpr; 3444 3445 Exprs.push_back(Result.takeAs<Expr>()); 3446 } 3447 3448 if (!getDerived().AlwaysRebuild() && !ExprsChanged) 3449 return SemaRef.Owned(S->Retain()); 3450 3451 // Go through the clobbers. 3452 for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I) 3453 Clobbers.push_back(S->getClobber(I)->Retain()); 3454 3455 // No need to transform the asm string literal. 3456 AsmString = SemaRef.Owned(S->getAsmString()); 3457 3458 return getDerived().RebuildAsmStmt(S->getAsmLoc(), 3459 S->isSimple(), 3460 S->isVolatile(), 3461 S->getNumOutputs(), 3462 S->getNumInputs(), 3463 Names.data(), 3464 move_arg(Constraints), 3465 move_arg(Exprs), 3466 move(AsmString), 3467 move_arg(Clobbers), 3468 S->getRParenLoc(), 3469 S->isMSAsm()); 3470} 3471 3472 3473template<typename Derived> 3474Sema::OwningStmtResult 3475TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) { 3476 // FIXME: Implement this 3477 assert(false && "Cannot transform an Objective-C @try statement"); 3478 return SemaRef.Owned(S->Retain()); 3479} 3480 3481template<typename Derived> 3482Sema::OwningStmtResult 3483TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) { 3484 // FIXME: Implement this 3485 assert(false && "Cannot transform an Objective-C @catch statement"); 3486 return SemaRef.Owned(S->Retain()); 3487} 3488 3489template<typename Derived> 3490Sema::OwningStmtResult 3491TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 3492 // FIXME: Implement this 3493 assert(false && "Cannot transform an Objective-C @finally statement"); 3494 return SemaRef.Owned(S->Retain()); 3495} 3496 3497template<typename Derived> 3498Sema::OwningStmtResult 3499TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) { 3500 // FIXME: Implement this 3501 assert(false && "Cannot transform an Objective-C @throw statement"); 3502 return SemaRef.Owned(S->Retain()); 3503} 3504 3505template<typename Derived> 3506Sema::OwningStmtResult 3507TreeTransform<Derived>::TransformObjCAtSynchronizedStmt( 3508 ObjCAtSynchronizedStmt *S) { 3509 // FIXME: Implement this 3510 assert(false && "Cannot transform an Objective-C @synchronized statement"); 3511 return SemaRef.Owned(S->Retain()); 3512} 3513 3514template<typename Derived> 3515Sema::OwningStmtResult 3516TreeTransform<Derived>::TransformObjCForCollectionStmt( 3517 ObjCForCollectionStmt *S) { 3518 // FIXME: Implement this 3519 assert(false && "Cannot transform an Objective-C for-each statement"); 3520 return SemaRef.Owned(S->Retain()); 3521} 3522 3523 3524template<typename Derived> 3525Sema::OwningStmtResult 3526TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) { 3527 // Transform the exception declaration, if any. 3528 VarDecl *Var = 0; 3529 if (S->getExceptionDecl()) { 3530 VarDecl *ExceptionDecl = S->getExceptionDecl(); 3531 TemporaryBase Rebase(*this, ExceptionDecl->getLocation(), 3532 ExceptionDecl->getDeclName()); 3533 3534 QualType T = getDerived().TransformType(ExceptionDecl->getType()); 3535 if (T.isNull()) 3536 return SemaRef.StmtError(); 3537 3538 Var = getDerived().RebuildExceptionDecl(ExceptionDecl, 3539 T, 3540 ExceptionDecl->getTypeSourceInfo(), 3541 ExceptionDecl->getIdentifier(), 3542 ExceptionDecl->getLocation(), 3543 /*FIXME: Inaccurate*/ 3544 SourceRange(ExceptionDecl->getLocation())); 3545 if (!Var || Var->isInvalidDecl()) { 3546 if (Var) 3547 Var->Destroy(SemaRef.Context); 3548 return SemaRef.StmtError(); 3549 } 3550 } 3551 3552 // Transform the actual exception handler. 3553 OwningStmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock()); 3554 if (Handler.isInvalid()) { 3555 if (Var) 3556 Var->Destroy(SemaRef.Context); 3557 return SemaRef.StmtError(); 3558 } 3559 3560 if (!getDerived().AlwaysRebuild() && 3561 !Var && 3562 Handler.get() == S->getHandlerBlock()) 3563 return SemaRef.Owned(S->Retain()); 3564 3565 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), 3566 Var, 3567 move(Handler)); 3568} 3569 3570template<typename Derived> 3571Sema::OwningStmtResult 3572TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) { 3573 // Transform the try block itself. 3574 OwningStmtResult TryBlock 3575 = getDerived().TransformCompoundStmt(S->getTryBlock()); 3576 if (TryBlock.isInvalid()) 3577 return SemaRef.StmtError(); 3578 3579 // Transform the handlers. 3580 bool HandlerChanged = false; 3581 ASTOwningVector<&ActionBase::DeleteStmt> Handlers(SemaRef); 3582 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) { 3583 OwningStmtResult Handler 3584 = getDerived().TransformCXXCatchStmt(S->getHandler(I)); 3585 if (Handler.isInvalid()) 3586 return SemaRef.StmtError(); 3587 3588 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I); 3589 Handlers.push_back(Handler.takeAs<Stmt>()); 3590 } 3591 3592 if (!getDerived().AlwaysRebuild() && 3593 TryBlock.get() == S->getTryBlock() && 3594 !HandlerChanged) 3595 return SemaRef.Owned(S->Retain()); 3596 3597 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), move(TryBlock), 3598 move_arg(Handlers)); 3599} 3600 3601//===----------------------------------------------------------------------===// 3602// Expression transformation 3603//===----------------------------------------------------------------------===// 3604template<typename Derived> 3605Sema::OwningExprResult 3606TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) { 3607 return SemaRef.Owned(E->Retain()); 3608} 3609 3610template<typename Derived> 3611Sema::OwningExprResult 3612TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) { 3613 NestedNameSpecifier *Qualifier = 0; 3614 if (E->getQualifier()) { 3615 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 3616 E->getQualifierRange()); 3617 if (!Qualifier) 3618 return SemaRef.ExprError(); 3619 } 3620 3621 ValueDecl *ND 3622 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(), 3623 E->getDecl())); 3624 if (!ND) 3625 return SemaRef.ExprError(); 3626 3627 if (!getDerived().AlwaysRebuild() && 3628 Qualifier == E->getQualifier() && 3629 ND == E->getDecl() && 3630 !E->hasExplicitTemplateArgumentList()) { 3631 3632 // Mark it referenced in the new context regardless. 3633 // FIXME: this is a bit instantiation-specific. 3634 SemaRef.MarkDeclarationReferenced(E->getLocation(), ND); 3635 3636 return SemaRef.Owned(E->Retain()); 3637 } 3638 3639 TemplateArgumentListInfo TransArgs, *TemplateArgs = 0; 3640 if (E->hasExplicitTemplateArgumentList()) { 3641 TemplateArgs = &TransArgs; 3642 TransArgs.setLAngleLoc(E->getLAngleLoc()); 3643 TransArgs.setRAngleLoc(E->getRAngleLoc()); 3644 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 3645 TemplateArgumentLoc Loc; 3646 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc)) 3647 return SemaRef.ExprError(); 3648 TransArgs.addArgument(Loc); 3649 } 3650 } 3651 3652 return getDerived().RebuildDeclRefExpr(Qualifier, E->getQualifierRange(), 3653 ND, E->getLocation(), TemplateArgs); 3654} 3655 3656template<typename Derived> 3657Sema::OwningExprResult 3658TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) { 3659 return SemaRef.Owned(E->Retain()); 3660} 3661 3662template<typename Derived> 3663Sema::OwningExprResult 3664TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) { 3665 return SemaRef.Owned(E->Retain()); 3666} 3667 3668template<typename Derived> 3669Sema::OwningExprResult 3670TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) { 3671 return SemaRef.Owned(E->Retain()); 3672} 3673 3674template<typename Derived> 3675Sema::OwningExprResult 3676TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) { 3677 return SemaRef.Owned(E->Retain()); 3678} 3679 3680template<typename Derived> 3681Sema::OwningExprResult 3682TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) { 3683 return SemaRef.Owned(E->Retain()); 3684} 3685 3686template<typename Derived> 3687Sema::OwningExprResult 3688TreeTransform<Derived>::TransformParenExpr(ParenExpr *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().RebuildParenExpr(move(SubExpr), E->getLParen(), 3697 E->getRParen()); 3698} 3699 3700template<typename Derived> 3701Sema::OwningExprResult 3702TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) { 3703 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 3704 if (SubExpr.isInvalid()) 3705 return SemaRef.ExprError(); 3706 3707 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 3708 return SemaRef.Owned(E->Retain()); 3709 3710 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(), 3711 E->getOpcode(), 3712 move(SubExpr)); 3713} 3714 3715template<typename Derived> 3716Sema::OwningExprResult 3717TreeTransform<Derived>::TransformSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { 3718 if (E->isArgumentType()) { 3719 TypeSourceInfo *OldT = E->getArgumentTypeInfo(); 3720 3721 TypeSourceInfo *NewT = getDerived().TransformType(OldT); 3722 if (!NewT) 3723 return SemaRef.ExprError(); 3724 3725 if (!getDerived().AlwaysRebuild() && OldT == NewT) 3726 return SemaRef.Owned(E->Retain()); 3727 3728 return getDerived().RebuildSizeOfAlignOf(NewT, E->getOperatorLoc(), 3729 E->isSizeOf(), 3730 E->getSourceRange()); 3731 } 3732 3733 Sema::OwningExprResult SubExpr(SemaRef); 3734 { 3735 // C++0x [expr.sizeof]p1: 3736 // The operand is either an expression, which is an unevaluated operand 3737 // [...] 3738 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 3739 3740 SubExpr = getDerived().TransformExpr(E->getArgumentExpr()); 3741 if (SubExpr.isInvalid()) 3742 return SemaRef.ExprError(); 3743 3744 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr()) 3745 return SemaRef.Owned(E->Retain()); 3746 } 3747 3748 return getDerived().RebuildSizeOfAlignOf(move(SubExpr), E->getOperatorLoc(), 3749 E->isSizeOf(), 3750 E->getSourceRange()); 3751} 3752 3753template<typename Derived> 3754Sema::OwningExprResult 3755TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) { 3756 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 3757 if (LHS.isInvalid()) 3758 return SemaRef.ExprError(); 3759 3760 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 3761 if (RHS.isInvalid()) 3762 return SemaRef.ExprError(); 3763 3764 3765 if (!getDerived().AlwaysRebuild() && 3766 LHS.get() == E->getLHS() && 3767 RHS.get() == E->getRHS()) 3768 return SemaRef.Owned(E->Retain()); 3769 3770 return getDerived().RebuildArraySubscriptExpr(move(LHS), 3771 /*FIXME:*/E->getLHS()->getLocStart(), 3772 move(RHS), 3773 E->getRBracketLoc()); 3774} 3775 3776template<typename Derived> 3777Sema::OwningExprResult 3778TreeTransform<Derived>::TransformCallExpr(CallExpr *E) { 3779 // Transform the callee. 3780 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee()); 3781 if (Callee.isInvalid()) 3782 return SemaRef.ExprError(); 3783 3784 // Transform arguments. 3785 bool ArgChanged = false; 3786 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 3787 llvm::SmallVector<SourceLocation, 4> FakeCommaLocs; 3788 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) { 3789 OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I)); 3790 if (Arg.isInvalid()) 3791 return SemaRef.ExprError(); 3792 3793 // FIXME: Wrong source location information for the ','. 3794 FakeCommaLocs.push_back( 3795 SemaRef.PP.getLocForEndOfToken(E->getArg(I)->getSourceRange().getEnd())); 3796 3797 ArgChanged = ArgChanged || Arg.get() != E->getArg(I); 3798 Args.push_back(Arg.takeAs<Expr>()); 3799 } 3800 3801 if (!getDerived().AlwaysRebuild() && 3802 Callee.get() == E->getCallee() && 3803 !ArgChanged) 3804 return SemaRef.Owned(E->Retain()); 3805 3806 // FIXME: Wrong source location information for the '('. 3807 SourceLocation FakeLParenLoc 3808 = ((Expr *)Callee.get())->getSourceRange().getBegin(); 3809 return getDerived().RebuildCallExpr(move(Callee), FakeLParenLoc, 3810 move_arg(Args), 3811 FakeCommaLocs.data(), 3812 E->getRParenLoc()); 3813} 3814 3815template<typename Derived> 3816Sema::OwningExprResult 3817TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) { 3818 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 3819 if (Base.isInvalid()) 3820 return SemaRef.ExprError(); 3821 3822 NestedNameSpecifier *Qualifier = 0; 3823 if (E->hasQualifier()) { 3824 Qualifier 3825 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 3826 E->getQualifierRange()); 3827 if (Qualifier == 0) 3828 return SemaRef.ExprError(); 3829 } 3830 3831 ValueDecl *Member 3832 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(), 3833 E->getMemberDecl())); 3834 if (!Member) 3835 return SemaRef.ExprError(); 3836 3837 if (!getDerived().AlwaysRebuild() && 3838 Base.get() == E->getBase() && 3839 Qualifier == E->getQualifier() && 3840 Member == E->getMemberDecl() && 3841 !E->hasExplicitTemplateArgumentList()) { 3842 3843 // Mark it referenced in the new context regardless. 3844 // FIXME: this is a bit instantiation-specific. 3845 SemaRef.MarkDeclarationReferenced(E->getMemberLoc(), Member); 3846 return SemaRef.Owned(E->Retain()); 3847 } 3848 3849 TemplateArgumentListInfo TransArgs; 3850 if (E->hasExplicitTemplateArgumentList()) { 3851 TransArgs.setLAngleLoc(E->getLAngleLoc()); 3852 TransArgs.setRAngleLoc(E->getRAngleLoc()); 3853 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 3854 TemplateArgumentLoc Loc; 3855 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc)) 3856 return SemaRef.ExprError(); 3857 TransArgs.addArgument(Loc); 3858 } 3859 } 3860 3861 // FIXME: Bogus source location for the operator 3862 SourceLocation FakeOperatorLoc 3863 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd()); 3864 3865 // FIXME: to do this check properly, we will need to preserve the 3866 // first-qualifier-in-scope here, just in case we had a dependent 3867 // base (and therefore couldn't do the check) and a 3868 // nested-name-qualifier (and therefore could do the lookup). 3869 NamedDecl *FirstQualifierInScope = 0; 3870 3871 return getDerived().RebuildMemberExpr(move(Base), FakeOperatorLoc, 3872 E->isArrow(), 3873 Qualifier, 3874 E->getQualifierRange(), 3875 E->getMemberLoc(), 3876 Member, 3877 (E->hasExplicitTemplateArgumentList() 3878 ? &TransArgs : 0), 3879 FirstQualifierInScope); 3880} 3881 3882template<typename Derived> 3883Sema::OwningExprResult 3884TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) { 3885 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 3886 if (LHS.isInvalid()) 3887 return SemaRef.ExprError(); 3888 3889 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 3890 if (RHS.isInvalid()) 3891 return SemaRef.ExprError(); 3892 3893 if (!getDerived().AlwaysRebuild() && 3894 LHS.get() == E->getLHS() && 3895 RHS.get() == E->getRHS()) 3896 return SemaRef.Owned(E->Retain()); 3897 3898 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(), 3899 move(LHS), move(RHS)); 3900} 3901 3902template<typename Derived> 3903Sema::OwningExprResult 3904TreeTransform<Derived>::TransformCompoundAssignOperator( 3905 CompoundAssignOperator *E) { 3906 return getDerived().TransformBinaryOperator(E); 3907} 3908 3909template<typename Derived> 3910Sema::OwningExprResult 3911TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) { 3912 OwningExprResult Cond = getDerived().TransformExpr(E->getCond()); 3913 if (Cond.isInvalid()) 3914 return SemaRef.ExprError(); 3915 3916 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 3917 if (LHS.isInvalid()) 3918 return SemaRef.ExprError(); 3919 3920 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 3921 if (RHS.isInvalid()) 3922 return SemaRef.ExprError(); 3923 3924 if (!getDerived().AlwaysRebuild() && 3925 Cond.get() == E->getCond() && 3926 LHS.get() == E->getLHS() && 3927 RHS.get() == E->getRHS()) 3928 return SemaRef.Owned(E->Retain()); 3929 3930 return getDerived().RebuildConditionalOperator(move(Cond), 3931 E->getQuestionLoc(), 3932 move(LHS), 3933 E->getColonLoc(), 3934 move(RHS)); 3935} 3936 3937template<typename Derived> 3938Sema::OwningExprResult 3939TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) { 3940 // Implicit casts are eliminated during transformation, since they 3941 // will be recomputed by semantic analysis after transformation. 3942 return getDerived().TransformExpr(E->getSubExprAsWritten()); 3943} 3944 3945template<typename Derived> 3946Sema::OwningExprResult 3947TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) { 3948 TypeSourceInfo *OldT; 3949 TypeSourceInfo *NewT; 3950 { 3951 // FIXME: Source location isn't quite accurate. 3952 SourceLocation TypeStartLoc 3953 = SemaRef.PP.getLocForEndOfToken(E->getLParenLoc()); 3954 TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName()); 3955 3956 OldT = E->getTypeInfoAsWritten(); 3957 NewT = getDerived().TransformType(OldT); 3958 if (!NewT) 3959 return SemaRef.ExprError(); 3960 } 3961 3962 OwningExprResult SubExpr 3963 = getDerived().TransformExpr(E->getSubExprAsWritten()); 3964 if (SubExpr.isInvalid()) 3965 return SemaRef.ExprError(); 3966 3967 if (!getDerived().AlwaysRebuild() && 3968 OldT == NewT && 3969 SubExpr.get() == E->getSubExpr()) 3970 return SemaRef.Owned(E->Retain()); 3971 3972 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(), 3973 NewT, 3974 E->getRParenLoc(), 3975 move(SubExpr)); 3976} 3977 3978template<typename Derived> 3979Sema::OwningExprResult 3980TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) { 3981 TypeSourceInfo *OldT = E->getTypeSourceInfo(); 3982 TypeSourceInfo *NewT = getDerived().TransformType(OldT); 3983 if (!NewT) 3984 return SemaRef.ExprError(); 3985 3986 OwningExprResult Init = getDerived().TransformExpr(E->getInitializer()); 3987 if (Init.isInvalid()) 3988 return SemaRef.ExprError(); 3989 3990 if (!getDerived().AlwaysRebuild() && 3991 OldT == NewT && 3992 Init.get() == E->getInitializer()) 3993 return SemaRef.Owned(E->Retain()); 3994 3995 // Note: the expression type doesn't necessarily match the 3996 // type-as-written, but that's okay, because it should always be 3997 // derivable from the initializer. 3998 3999 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), NewT, 4000 /*FIXME:*/E->getInitializer()->getLocEnd(), 4001 move(Init)); 4002} 4003 4004template<typename Derived> 4005Sema::OwningExprResult 4006TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) { 4007 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 4008 if (Base.isInvalid()) 4009 return SemaRef.ExprError(); 4010 4011 if (!getDerived().AlwaysRebuild() && 4012 Base.get() == E->getBase()) 4013 return SemaRef.Owned(E->Retain()); 4014 4015 // FIXME: Bad source location 4016 SourceLocation FakeOperatorLoc 4017 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getLocEnd()); 4018 return getDerived().RebuildExtVectorElementExpr(move(Base), FakeOperatorLoc, 4019 E->getAccessorLoc(), 4020 E->getAccessor()); 4021} 4022 4023template<typename Derived> 4024Sema::OwningExprResult 4025TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) { 4026 bool InitChanged = false; 4027 4028 ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef); 4029 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) { 4030 OwningExprResult Init = getDerived().TransformExpr(E->getInit(I)); 4031 if (Init.isInvalid()) 4032 return SemaRef.ExprError(); 4033 4034 InitChanged = InitChanged || Init.get() != E->getInit(I); 4035 Inits.push_back(Init.takeAs<Expr>()); 4036 } 4037 4038 if (!getDerived().AlwaysRebuild() && !InitChanged) 4039 return SemaRef.Owned(E->Retain()); 4040 4041 return getDerived().RebuildInitList(E->getLBraceLoc(), move_arg(Inits), 4042 E->getRBraceLoc(), E->getType()); 4043} 4044 4045template<typename Derived> 4046Sema::OwningExprResult 4047TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { 4048 Designation Desig; 4049 4050 // transform the initializer value 4051 OwningExprResult Init = getDerived().TransformExpr(E->getInit()); 4052 if (Init.isInvalid()) 4053 return SemaRef.ExprError(); 4054 4055 // transform the designators. 4056 ASTOwningVector<&ActionBase::DeleteExpr, 4> ArrayExprs(SemaRef); 4057 bool ExprChanged = false; 4058 for (DesignatedInitExpr::designators_iterator D = E->designators_begin(), 4059 DEnd = E->designators_end(); 4060 D != DEnd; ++D) { 4061 if (D->isFieldDesignator()) { 4062 Desig.AddDesignator(Designator::getField(D->getFieldName(), 4063 D->getDotLoc(), 4064 D->getFieldLoc())); 4065 continue; 4066 } 4067 4068 if (D->isArrayDesignator()) { 4069 OwningExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D)); 4070 if (Index.isInvalid()) 4071 return SemaRef.ExprError(); 4072 4073 Desig.AddDesignator(Designator::getArray(Index.get(), 4074 D->getLBracketLoc())); 4075 4076 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D); 4077 ArrayExprs.push_back(Index.release()); 4078 continue; 4079 } 4080 4081 assert(D->isArrayRangeDesignator() && "New kind of designator?"); 4082 OwningExprResult Start 4083 = getDerived().TransformExpr(E->getArrayRangeStart(*D)); 4084 if (Start.isInvalid()) 4085 return SemaRef.ExprError(); 4086 4087 OwningExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D)); 4088 if (End.isInvalid()) 4089 return SemaRef.ExprError(); 4090 4091 Desig.AddDesignator(Designator::getArrayRange(Start.get(), 4092 End.get(), 4093 D->getLBracketLoc(), 4094 D->getEllipsisLoc())); 4095 4096 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) || 4097 End.get() != E->getArrayRangeEnd(*D); 4098 4099 ArrayExprs.push_back(Start.release()); 4100 ArrayExprs.push_back(End.release()); 4101 } 4102 4103 if (!getDerived().AlwaysRebuild() && 4104 Init.get() == E->getInit() && 4105 !ExprChanged) 4106 return SemaRef.Owned(E->Retain()); 4107 4108 return getDerived().RebuildDesignatedInitExpr(Desig, move_arg(ArrayExprs), 4109 E->getEqualOrColonLoc(), 4110 E->usesGNUSyntax(), move(Init)); 4111} 4112 4113template<typename Derived> 4114Sema::OwningExprResult 4115TreeTransform<Derived>::TransformImplicitValueInitExpr( 4116 ImplicitValueInitExpr *E) { 4117 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 4118 4119 // FIXME: Will we ever have proper type location here? Will we actually 4120 // need to transform the type? 4121 QualType T = getDerived().TransformType(E->getType()); 4122 if (T.isNull()) 4123 return SemaRef.ExprError(); 4124 4125 if (!getDerived().AlwaysRebuild() && 4126 T == E->getType()) 4127 return SemaRef.Owned(E->Retain()); 4128 4129 return getDerived().RebuildImplicitValueInitExpr(T); 4130} 4131 4132template<typename Derived> 4133Sema::OwningExprResult 4134TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) { 4135 // FIXME: Do we want the type as written? 4136 QualType T; 4137 4138 { 4139 // FIXME: Source location isn't quite accurate. 4140 TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName()); 4141 T = getDerived().TransformType(E->getType()); 4142 if (T.isNull()) 4143 return SemaRef.ExprError(); 4144 } 4145 4146 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4147 if (SubExpr.isInvalid()) 4148 return SemaRef.ExprError(); 4149 4150 if (!getDerived().AlwaysRebuild() && 4151 T == E->getType() && 4152 SubExpr.get() == E->getSubExpr()) 4153 return SemaRef.Owned(E->Retain()); 4154 4155 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), move(SubExpr), 4156 T, E->getRParenLoc()); 4157} 4158 4159template<typename Derived> 4160Sema::OwningExprResult 4161TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) { 4162 bool ArgumentChanged = false; 4163 ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef); 4164 for (unsigned I = 0, N = E->getNumExprs(); I != N; ++I) { 4165 OwningExprResult Init = getDerived().TransformExpr(E->getExpr(I)); 4166 if (Init.isInvalid()) 4167 return SemaRef.ExprError(); 4168 4169 ArgumentChanged = ArgumentChanged || Init.get() != E->getExpr(I); 4170 Inits.push_back(Init.takeAs<Expr>()); 4171 } 4172 4173 return getDerived().RebuildParenListExpr(E->getLParenLoc(), 4174 move_arg(Inits), 4175 E->getRParenLoc()); 4176} 4177 4178/// \brief Transform an address-of-label expression. 4179/// 4180/// By default, the transformation of an address-of-label expression always 4181/// rebuilds the expression, so that the label identifier can be resolved to 4182/// the corresponding label statement by semantic analysis. 4183template<typename Derived> 4184Sema::OwningExprResult 4185TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) { 4186 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(), 4187 E->getLabel()); 4188} 4189 4190template<typename Derived> 4191Sema::OwningExprResult 4192TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) { 4193 OwningStmtResult SubStmt 4194 = getDerived().TransformCompoundStmt(E->getSubStmt(), true); 4195 if (SubStmt.isInvalid()) 4196 return SemaRef.ExprError(); 4197 4198 if (!getDerived().AlwaysRebuild() && 4199 SubStmt.get() == E->getSubStmt()) 4200 return SemaRef.Owned(E->Retain()); 4201 4202 return getDerived().RebuildStmtExpr(E->getLParenLoc(), 4203 move(SubStmt), 4204 E->getRParenLoc()); 4205} 4206 4207template<typename Derived> 4208Sema::OwningExprResult 4209TreeTransform<Derived>::TransformTypesCompatibleExpr(TypesCompatibleExpr *E) { 4210 QualType T1, T2; 4211 { 4212 // FIXME: Source location isn't quite accurate. 4213 TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName()); 4214 4215 T1 = getDerived().TransformType(E->getArgType1()); 4216 if (T1.isNull()) 4217 return SemaRef.ExprError(); 4218 4219 T2 = getDerived().TransformType(E->getArgType2()); 4220 if (T2.isNull()) 4221 return SemaRef.ExprError(); 4222 } 4223 4224 if (!getDerived().AlwaysRebuild() && 4225 T1 == E->getArgType1() && 4226 T2 == E->getArgType2()) 4227 return SemaRef.Owned(E->Retain()); 4228 4229 return getDerived().RebuildTypesCompatibleExpr(E->getBuiltinLoc(), 4230 T1, T2, E->getRParenLoc()); 4231} 4232 4233template<typename Derived> 4234Sema::OwningExprResult 4235TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) { 4236 OwningExprResult Cond = getDerived().TransformExpr(E->getCond()); 4237 if (Cond.isInvalid()) 4238 return SemaRef.ExprError(); 4239 4240 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 4241 if (LHS.isInvalid()) 4242 return SemaRef.ExprError(); 4243 4244 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 4245 if (RHS.isInvalid()) 4246 return SemaRef.ExprError(); 4247 4248 if (!getDerived().AlwaysRebuild() && 4249 Cond.get() == E->getCond() && 4250 LHS.get() == E->getLHS() && 4251 RHS.get() == E->getRHS()) 4252 return SemaRef.Owned(E->Retain()); 4253 4254 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(), 4255 move(Cond), move(LHS), move(RHS), 4256 E->getRParenLoc()); 4257} 4258 4259template<typename Derived> 4260Sema::OwningExprResult 4261TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) { 4262 return SemaRef.Owned(E->Retain()); 4263} 4264 4265template<typename Derived> 4266Sema::OwningExprResult 4267TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 4268 switch (E->getOperator()) { 4269 case OO_New: 4270 case OO_Delete: 4271 case OO_Array_New: 4272 case OO_Array_Delete: 4273 llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr"); 4274 return SemaRef.ExprError(); 4275 4276 case OO_Call: { 4277 // This is a call to an object's operator(). 4278 assert(E->getNumArgs() >= 1 && "Object call is missing arguments"); 4279 4280 // Transform the object itself. 4281 OwningExprResult Object = getDerived().TransformExpr(E->getArg(0)); 4282 if (Object.isInvalid()) 4283 return SemaRef.ExprError(); 4284 4285 // FIXME: Poor location information 4286 SourceLocation FakeLParenLoc 4287 = SemaRef.PP.getLocForEndOfToken( 4288 static_cast<Expr *>(Object.get())->getLocEnd()); 4289 4290 // Transform the call arguments. 4291 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 4292 llvm::SmallVector<SourceLocation, 4> FakeCommaLocs; 4293 for (unsigned I = 1, N = E->getNumArgs(); I != N; ++I) { 4294 if (getDerived().DropCallArgument(E->getArg(I))) 4295 break; 4296 4297 OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I)); 4298 if (Arg.isInvalid()) 4299 return SemaRef.ExprError(); 4300 4301 // FIXME: Poor source location information. 4302 SourceLocation FakeCommaLoc 4303 = SemaRef.PP.getLocForEndOfToken( 4304 static_cast<Expr *>(Arg.get())->getLocEnd()); 4305 FakeCommaLocs.push_back(FakeCommaLoc); 4306 Args.push_back(Arg.release()); 4307 } 4308 4309 return getDerived().RebuildCallExpr(move(Object), FakeLParenLoc, 4310 move_arg(Args), 4311 FakeCommaLocs.data(), 4312 E->getLocEnd()); 4313 } 4314 4315#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ 4316 case OO_##Name: 4317#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly) 4318#include "clang/Basic/OperatorKinds.def" 4319 case OO_Subscript: 4320 // Handled below. 4321 break; 4322 4323 case OO_Conditional: 4324 llvm_unreachable("conditional operator is not actually overloadable"); 4325 return SemaRef.ExprError(); 4326 4327 case OO_None: 4328 case NUM_OVERLOADED_OPERATORS: 4329 llvm_unreachable("not an overloaded operator?"); 4330 return SemaRef.ExprError(); 4331 } 4332 4333 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee()); 4334 if (Callee.isInvalid()) 4335 return SemaRef.ExprError(); 4336 4337 OwningExprResult First = getDerived().TransformExpr(E->getArg(0)); 4338 if (First.isInvalid()) 4339 return SemaRef.ExprError(); 4340 4341 OwningExprResult Second(SemaRef); 4342 if (E->getNumArgs() == 2) { 4343 Second = getDerived().TransformExpr(E->getArg(1)); 4344 if (Second.isInvalid()) 4345 return SemaRef.ExprError(); 4346 } 4347 4348 if (!getDerived().AlwaysRebuild() && 4349 Callee.get() == E->getCallee() && 4350 First.get() == E->getArg(0) && 4351 (E->getNumArgs() != 2 || Second.get() == E->getArg(1))) 4352 return SemaRef.Owned(E->Retain()); 4353 4354 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(), 4355 E->getOperatorLoc(), 4356 move(Callee), 4357 move(First), 4358 move(Second)); 4359} 4360 4361template<typename Derived> 4362Sema::OwningExprResult 4363TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) { 4364 return getDerived().TransformCallExpr(E); 4365} 4366 4367template<typename Derived> 4368Sema::OwningExprResult 4369TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) { 4370 TypeSourceInfo *OldT; 4371 TypeSourceInfo *NewT; 4372 { 4373 // FIXME: Source location isn't quite accurate. 4374 SourceLocation TypeStartLoc 4375 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc()); 4376 TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName()); 4377 4378 OldT = E->getTypeInfoAsWritten(); 4379 NewT = getDerived().TransformType(OldT); 4380 if (!NewT) 4381 return SemaRef.ExprError(); 4382 } 4383 4384 OwningExprResult SubExpr 4385 = getDerived().TransformExpr(E->getSubExprAsWritten()); 4386 if (SubExpr.isInvalid()) 4387 return SemaRef.ExprError(); 4388 4389 if (!getDerived().AlwaysRebuild() && 4390 OldT == NewT && 4391 SubExpr.get() == E->getSubExpr()) 4392 return SemaRef.Owned(E->Retain()); 4393 4394 // FIXME: Poor source location information here. 4395 SourceLocation FakeLAngleLoc 4396 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc()); 4397 SourceLocation FakeRAngleLoc = E->getSubExpr()->getSourceRange().getBegin(); 4398 SourceLocation FakeRParenLoc 4399 = SemaRef.PP.getLocForEndOfToken( 4400 E->getSubExpr()->getSourceRange().getEnd()); 4401 return getDerived().RebuildCXXNamedCastExpr(E->getOperatorLoc(), 4402 E->getStmtClass(), 4403 FakeLAngleLoc, 4404 NewT, 4405 FakeRAngleLoc, 4406 FakeRAngleLoc, 4407 move(SubExpr), 4408 FakeRParenLoc); 4409} 4410 4411template<typename Derived> 4412Sema::OwningExprResult 4413TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) { 4414 return getDerived().TransformCXXNamedCastExpr(E); 4415} 4416 4417template<typename Derived> 4418Sema::OwningExprResult 4419TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) { 4420 return getDerived().TransformCXXNamedCastExpr(E); 4421} 4422 4423template<typename Derived> 4424Sema::OwningExprResult 4425TreeTransform<Derived>::TransformCXXReinterpretCastExpr( 4426 CXXReinterpretCastExpr *E) { 4427 return getDerived().TransformCXXNamedCastExpr(E); 4428} 4429 4430template<typename Derived> 4431Sema::OwningExprResult 4432TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) { 4433 return getDerived().TransformCXXNamedCastExpr(E); 4434} 4435 4436template<typename Derived> 4437Sema::OwningExprResult 4438TreeTransform<Derived>::TransformCXXFunctionalCastExpr( 4439 CXXFunctionalCastExpr *E) { 4440 TypeSourceInfo *OldT; 4441 TypeSourceInfo *NewT; 4442 { 4443 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 4444 4445 OldT = E->getTypeInfoAsWritten(); 4446 NewT = getDerived().TransformType(OldT); 4447 if (!NewT) 4448 return SemaRef.ExprError(); 4449 } 4450 4451 OwningExprResult SubExpr 4452 = getDerived().TransformExpr(E->getSubExprAsWritten()); 4453 if (SubExpr.isInvalid()) 4454 return SemaRef.ExprError(); 4455 4456 if (!getDerived().AlwaysRebuild() && 4457 OldT == NewT && 4458 SubExpr.get() == E->getSubExpr()) 4459 return SemaRef.Owned(E->Retain()); 4460 4461 // FIXME: The end of the type's source range is wrong 4462 return getDerived().RebuildCXXFunctionalCastExpr( 4463 /*FIXME:*/SourceRange(E->getTypeBeginLoc()), 4464 NewT, 4465 /*FIXME:*/E->getSubExpr()->getLocStart(), 4466 move(SubExpr), 4467 E->getRParenLoc()); 4468} 4469 4470template<typename Derived> 4471Sema::OwningExprResult 4472TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) { 4473 if (E->isTypeOperand()) { 4474 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 4475 4476 QualType T = getDerived().TransformType(E->getTypeOperand()); 4477 if (T.isNull()) 4478 return SemaRef.ExprError(); 4479 4480 if (!getDerived().AlwaysRebuild() && 4481 T == E->getTypeOperand()) 4482 return SemaRef.Owned(E->Retain()); 4483 4484 return getDerived().RebuildCXXTypeidExpr(E->getLocStart(), 4485 /*FIXME:*/E->getLocStart(), 4486 T, 4487 E->getLocEnd()); 4488 } 4489 4490 // We don't know whether the expression is potentially evaluated until 4491 // after we perform semantic analysis, so the expression is potentially 4492 // potentially evaluated. 4493 EnterExpressionEvaluationContext Unevaluated(SemaRef, 4494 Action::PotentiallyPotentiallyEvaluated); 4495 4496 OwningExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); 4497 if (SubExpr.isInvalid()) 4498 return SemaRef.ExprError(); 4499 4500 if (!getDerived().AlwaysRebuild() && 4501 SubExpr.get() == E->getExprOperand()) 4502 return SemaRef.Owned(E->Retain()); 4503 4504 return getDerived().RebuildCXXTypeidExpr(E->getLocStart(), 4505 /*FIXME:*/E->getLocStart(), 4506 move(SubExpr), 4507 E->getLocEnd()); 4508} 4509 4510template<typename Derived> 4511Sema::OwningExprResult 4512TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 4513 return SemaRef.Owned(E->Retain()); 4514} 4515 4516template<typename Derived> 4517Sema::OwningExprResult 4518TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr( 4519 CXXNullPtrLiteralExpr *E) { 4520 return SemaRef.Owned(E->Retain()); 4521} 4522 4523template<typename Derived> 4524Sema::OwningExprResult 4525TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) { 4526 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 4527 4528 QualType T = getDerived().TransformType(E->getType()); 4529 if (T.isNull()) 4530 return SemaRef.ExprError(); 4531 4532 if (!getDerived().AlwaysRebuild() && 4533 T == E->getType()) 4534 return SemaRef.Owned(E->Retain()); 4535 4536 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T, E->isImplicit()); 4537} 4538 4539template<typename Derived> 4540Sema::OwningExprResult 4541TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) { 4542 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4543 if (SubExpr.isInvalid()) 4544 return SemaRef.ExprError(); 4545 4546 if (!getDerived().AlwaysRebuild() && 4547 SubExpr.get() == E->getSubExpr()) 4548 return SemaRef.Owned(E->Retain()); 4549 4550 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), move(SubExpr)); 4551} 4552 4553template<typename Derived> 4554Sema::OwningExprResult 4555TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 4556 ParmVarDecl *Param 4557 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getLocStart(), 4558 E->getParam())); 4559 if (!Param) 4560 return SemaRef.ExprError(); 4561 4562 if (!getDerived().AlwaysRebuild() && 4563 Param == E->getParam()) 4564 return SemaRef.Owned(E->Retain()); 4565 4566 return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param); 4567} 4568 4569template<typename Derived> 4570Sema::OwningExprResult 4571TreeTransform<Derived>::TransformCXXZeroInitValueExpr(CXXZeroInitValueExpr *E) { 4572 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 4573 4574 QualType T = getDerived().TransformType(E->getType()); 4575 if (T.isNull()) 4576 return SemaRef.ExprError(); 4577 4578 if (!getDerived().AlwaysRebuild() && 4579 T == E->getType()) 4580 return SemaRef.Owned(E->Retain()); 4581 4582 return getDerived().RebuildCXXZeroInitValueExpr(E->getTypeBeginLoc(), 4583 /*FIXME:*/E->getTypeBeginLoc(), 4584 T, 4585 E->getRParenLoc()); 4586} 4587 4588template<typename Derived> 4589Sema::OwningExprResult 4590TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { 4591 // Transform the type that we're allocating 4592 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 4593 QualType AllocType = getDerived().TransformType(E->getAllocatedType()); 4594 if (AllocType.isNull()) 4595 return SemaRef.ExprError(); 4596 4597 // Transform the size of the array we're allocating (if any). 4598 OwningExprResult ArraySize = getDerived().TransformExpr(E->getArraySize()); 4599 if (ArraySize.isInvalid()) 4600 return SemaRef.ExprError(); 4601 4602 // Transform the placement arguments (if any). 4603 bool ArgumentChanged = false; 4604 ASTOwningVector<&ActionBase::DeleteExpr> PlacementArgs(SemaRef); 4605 for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) { 4606 OwningExprResult Arg = getDerived().TransformExpr(E->getPlacementArg(I)); 4607 if (Arg.isInvalid()) 4608 return SemaRef.ExprError(); 4609 4610 ArgumentChanged = ArgumentChanged || Arg.get() != E->getPlacementArg(I); 4611 PlacementArgs.push_back(Arg.take()); 4612 } 4613 4614 // transform the constructor arguments (if any). 4615 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(SemaRef); 4616 for (unsigned I = 0, N = E->getNumConstructorArgs(); I != N; ++I) { 4617 OwningExprResult Arg = getDerived().TransformExpr(E->getConstructorArg(I)); 4618 if (Arg.isInvalid()) 4619 return SemaRef.ExprError(); 4620 4621 ArgumentChanged = ArgumentChanged || Arg.get() != E->getConstructorArg(I); 4622 ConstructorArgs.push_back(Arg.take()); 4623 } 4624 4625 // Transform constructor, new operator, and delete operator. 4626 CXXConstructorDecl *Constructor = 0; 4627 if (E->getConstructor()) { 4628 Constructor = cast_or_null<CXXConstructorDecl>( 4629 getDerived().TransformDecl(E->getLocStart(), 4630 E->getConstructor())); 4631 if (!Constructor) 4632 return SemaRef.ExprError(); 4633 } 4634 4635 FunctionDecl *OperatorNew = 0; 4636 if (E->getOperatorNew()) { 4637 OperatorNew = cast_or_null<FunctionDecl>( 4638 getDerived().TransformDecl(E->getLocStart(), 4639 E->getOperatorNew())); 4640 if (!OperatorNew) 4641 return SemaRef.ExprError(); 4642 } 4643 4644 FunctionDecl *OperatorDelete = 0; 4645 if (E->getOperatorDelete()) { 4646 OperatorDelete = cast_or_null<FunctionDecl>( 4647 getDerived().TransformDecl(E->getLocStart(), 4648 E->getOperatorDelete())); 4649 if (!OperatorDelete) 4650 return SemaRef.ExprError(); 4651 } 4652 4653 if (!getDerived().AlwaysRebuild() && 4654 AllocType == E->getAllocatedType() && 4655 ArraySize.get() == E->getArraySize() && 4656 Constructor == E->getConstructor() && 4657 OperatorNew == E->getOperatorNew() && 4658 OperatorDelete == E->getOperatorDelete() && 4659 !ArgumentChanged) { 4660 // Mark any declarations we need as referenced. 4661 // FIXME: instantiation-specific. 4662 if (Constructor) 4663 SemaRef.MarkDeclarationReferenced(E->getLocStart(), Constructor); 4664 if (OperatorNew) 4665 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorNew); 4666 if (OperatorDelete) 4667 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorDelete); 4668 return SemaRef.Owned(E->Retain()); 4669 } 4670 4671 if (!ArraySize.get()) { 4672 // If no array size was specified, but the new expression was 4673 // instantiated with an array type (e.g., "new T" where T is 4674 // instantiated with "int[4]"), extract the outer bound from the 4675 // array type as our array size. We do this with constant and 4676 // dependently-sized array types. 4677 const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType); 4678 if (!ArrayT) { 4679 // Do nothing 4680 } else if (const ConstantArrayType *ConsArrayT 4681 = dyn_cast<ConstantArrayType>(ArrayT)) { 4682 ArraySize 4683 = SemaRef.Owned(new (SemaRef.Context) IntegerLiteral( 4684 ConsArrayT->getSize(), 4685 SemaRef.Context.getSizeType(), 4686 /*FIXME:*/E->getLocStart())); 4687 AllocType = ConsArrayT->getElementType(); 4688 } else if (const DependentSizedArrayType *DepArrayT 4689 = dyn_cast<DependentSizedArrayType>(ArrayT)) { 4690 if (DepArrayT->getSizeExpr()) { 4691 ArraySize = SemaRef.Owned(DepArrayT->getSizeExpr()->Retain()); 4692 AllocType = DepArrayT->getElementType(); 4693 } 4694 } 4695 } 4696 return getDerived().RebuildCXXNewExpr(E->getLocStart(), 4697 E->isGlobalNew(), 4698 /*FIXME:*/E->getLocStart(), 4699 move_arg(PlacementArgs), 4700 /*FIXME:*/E->getLocStart(), 4701 E->isParenTypeId(), 4702 AllocType, 4703 /*FIXME:*/E->getLocStart(), 4704 /*FIXME:*/SourceRange(), 4705 move(ArraySize), 4706 /*FIXME:*/E->getLocStart(), 4707 move_arg(ConstructorArgs), 4708 E->getLocEnd()); 4709} 4710 4711template<typename Derived> 4712Sema::OwningExprResult 4713TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) { 4714 OwningExprResult Operand = getDerived().TransformExpr(E->getArgument()); 4715 if (Operand.isInvalid()) 4716 return SemaRef.ExprError(); 4717 4718 // Transform the delete operator, if known. 4719 FunctionDecl *OperatorDelete = 0; 4720 if (E->getOperatorDelete()) { 4721 OperatorDelete = cast_or_null<FunctionDecl>( 4722 getDerived().TransformDecl(E->getLocStart(), 4723 E->getOperatorDelete())); 4724 if (!OperatorDelete) 4725 return SemaRef.ExprError(); 4726 } 4727 4728 if (!getDerived().AlwaysRebuild() && 4729 Operand.get() == E->getArgument() && 4730 OperatorDelete == E->getOperatorDelete()) { 4731 // Mark any declarations we need as referenced. 4732 // FIXME: instantiation-specific. 4733 if (OperatorDelete) 4734 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorDelete); 4735 return SemaRef.Owned(E->Retain()); 4736 } 4737 4738 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(), 4739 E->isGlobalDelete(), 4740 E->isArrayForm(), 4741 move(Operand)); 4742} 4743 4744template<typename Derived> 4745Sema::OwningExprResult 4746TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( 4747 CXXPseudoDestructorExpr *E) { 4748 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 4749 if (Base.isInvalid()) 4750 return SemaRef.ExprError(); 4751 4752 Sema::TypeTy *ObjectTypePtr = 0; 4753 bool MayBePseudoDestructor = false; 4754 Base = SemaRef.ActOnStartCXXMemberReference(0, move(Base), 4755 E->getOperatorLoc(), 4756 E->isArrow()? tok::arrow : tok::period, 4757 ObjectTypePtr, 4758 MayBePseudoDestructor); 4759 if (Base.isInvalid()) 4760 return SemaRef.ExprError(); 4761 4762 QualType ObjectType = QualType::getFromOpaquePtr(ObjectTypePtr); 4763 NestedNameSpecifier *Qualifier 4764 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 4765 E->getQualifierRange(), 4766 ObjectType); 4767 if (E->getQualifier() && !Qualifier) 4768 return SemaRef.ExprError(); 4769 4770 PseudoDestructorTypeStorage Destroyed; 4771 if (E->getDestroyedTypeInfo()) { 4772 TypeSourceInfo *DestroyedTypeInfo 4773 = getDerived().TransformType(E->getDestroyedTypeInfo(), ObjectType); 4774 if (!DestroyedTypeInfo) 4775 return SemaRef.ExprError(); 4776 Destroyed = DestroyedTypeInfo; 4777 } else if (ObjectType->isDependentType()) { 4778 // We aren't likely to be able to resolve the identifier down to a type 4779 // now anyway, so just retain the identifier. 4780 Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(), 4781 E->getDestroyedTypeLoc()); 4782 } else { 4783 // Look for a destructor known with the given name. 4784 CXXScopeSpec SS; 4785 if (Qualifier) { 4786 SS.setScopeRep(Qualifier); 4787 SS.setRange(E->getQualifierRange()); 4788 } 4789 4790 Sema::TypeTy *T = SemaRef.getDestructorName(E->getTildeLoc(), 4791 *E->getDestroyedTypeIdentifier(), 4792 E->getDestroyedTypeLoc(), 4793 /*Scope=*/0, 4794 SS, ObjectTypePtr, 4795 false); 4796 if (!T) 4797 return SemaRef.ExprError(); 4798 4799 Destroyed 4800 = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T), 4801 E->getDestroyedTypeLoc()); 4802 } 4803 4804 TypeSourceInfo *ScopeTypeInfo = 0; 4805 if (E->getScopeTypeInfo()) { 4806 ScopeTypeInfo = getDerived().TransformType(E->getScopeTypeInfo(), 4807 ObjectType); 4808 if (!ScopeTypeInfo) 4809 return SemaRef.ExprError(); 4810 } 4811 4812 return getDerived().RebuildCXXPseudoDestructorExpr(move(Base), 4813 E->getOperatorLoc(), 4814 E->isArrow(), 4815 Qualifier, 4816 E->getQualifierRange(), 4817 ScopeTypeInfo, 4818 E->getColonColonLoc(), 4819 E->getTildeLoc(), 4820 Destroyed); 4821} 4822 4823template<typename Derived> 4824Sema::OwningExprResult 4825TreeTransform<Derived>::TransformUnresolvedLookupExpr( 4826 UnresolvedLookupExpr *Old) { 4827 TemporaryBase Rebase(*this, Old->getNameLoc(), DeclarationName()); 4828 4829 LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(), 4830 Sema::LookupOrdinaryName); 4831 4832 // Transform all the decls. 4833 for (UnresolvedLookupExpr::decls_iterator I = Old->decls_begin(), 4834 E = Old->decls_end(); I != E; ++I) { 4835 NamedDecl *InstD = static_cast<NamedDecl*>( 4836 getDerived().TransformDecl(Old->getNameLoc(), 4837 *I)); 4838 if (!InstD) { 4839 // Silently ignore these if a UsingShadowDecl instantiated to nothing. 4840 // This can happen because of dependent hiding. 4841 if (isa<UsingShadowDecl>(*I)) 4842 continue; 4843 else 4844 return SemaRef.ExprError(); 4845 } 4846 4847 // Expand using declarations. 4848 if (isa<UsingDecl>(InstD)) { 4849 UsingDecl *UD = cast<UsingDecl>(InstD); 4850 for (UsingDecl::shadow_iterator I = UD->shadow_begin(), 4851 E = UD->shadow_end(); I != E; ++I) 4852 R.addDecl(*I); 4853 continue; 4854 } 4855 4856 R.addDecl(InstD); 4857 } 4858 4859 // Resolve a kind, but don't do any further analysis. If it's 4860 // ambiguous, the callee needs to deal with it. 4861 R.resolveKind(); 4862 4863 // Rebuild the nested-name qualifier, if present. 4864 CXXScopeSpec SS; 4865 NestedNameSpecifier *Qualifier = 0; 4866 if (Old->getQualifier()) { 4867 Qualifier = getDerived().TransformNestedNameSpecifier(Old->getQualifier(), 4868 Old->getQualifierRange()); 4869 if (!Qualifier) 4870 return SemaRef.ExprError(); 4871 4872 SS.setScopeRep(Qualifier); 4873 SS.setRange(Old->getQualifierRange()); 4874 } 4875 4876 // If we have no template arguments, it's a normal declaration name. 4877 if (!Old->hasExplicitTemplateArgs()) 4878 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL()); 4879 4880 // If we have template arguments, rebuild them, then rebuild the 4881 // templateid expression. 4882 TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc()); 4883 for (unsigned I = 0, N = Old->getNumTemplateArgs(); I != N; ++I) { 4884 TemplateArgumentLoc Loc; 4885 if (getDerived().TransformTemplateArgument(Old->getTemplateArgs()[I], Loc)) 4886 return SemaRef.ExprError(); 4887 TransArgs.addArgument(Loc); 4888 } 4889 4890 return getDerived().RebuildTemplateIdExpr(SS, R, Old->requiresADL(), 4891 TransArgs); 4892} 4893 4894template<typename Derived> 4895Sema::OwningExprResult 4896TreeTransform<Derived>::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { 4897 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 4898 4899 QualType T = getDerived().TransformType(E->getQueriedType()); 4900 if (T.isNull()) 4901 return SemaRef.ExprError(); 4902 4903 if (!getDerived().AlwaysRebuild() && 4904 T == E->getQueriedType()) 4905 return SemaRef.Owned(E->Retain()); 4906 4907 // FIXME: Bad location information 4908 SourceLocation FakeLParenLoc 4909 = SemaRef.PP.getLocForEndOfToken(E->getLocStart()); 4910 4911 return getDerived().RebuildUnaryTypeTrait(E->getTrait(), 4912 E->getLocStart(), 4913 /*FIXME:*/FakeLParenLoc, 4914 T, 4915 E->getLocEnd()); 4916} 4917 4918template<typename Derived> 4919Sema::OwningExprResult 4920TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( 4921 DependentScopeDeclRefExpr *E) { 4922 NestedNameSpecifier *NNS 4923 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 4924 E->getQualifierRange()); 4925 if (!NNS) 4926 return SemaRef.ExprError(); 4927 4928 DeclarationName Name 4929 = getDerived().TransformDeclarationName(E->getDeclName(), E->getLocation()); 4930 if (!Name) 4931 return SemaRef.ExprError(); 4932 4933 if (!E->hasExplicitTemplateArgs()) { 4934 if (!getDerived().AlwaysRebuild() && 4935 NNS == E->getQualifier() && 4936 Name == E->getDeclName()) 4937 return SemaRef.Owned(E->Retain()); 4938 4939 return getDerived().RebuildDependentScopeDeclRefExpr(NNS, 4940 E->getQualifierRange(), 4941 Name, E->getLocation(), 4942 /*TemplateArgs*/ 0); 4943 } 4944 4945 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 4946 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 4947 TemplateArgumentLoc Loc; 4948 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc)) 4949 return SemaRef.ExprError(); 4950 TransArgs.addArgument(Loc); 4951 } 4952 4953 return getDerived().RebuildDependentScopeDeclRefExpr(NNS, 4954 E->getQualifierRange(), 4955 Name, E->getLocation(), 4956 &TransArgs); 4957} 4958 4959template<typename Derived> 4960Sema::OwningExprResult 4961TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) { 4962 // CXXConstructExprs are always implicit, so when we have a 4963 // 1-argument construction we just transform that argument. 4964 if (E->getNumArgs() == 1 || 4965 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) 4966 return getDerived().TransformExpr(E->getArg(0)); 4967 4968 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 4969 4970 QualType T = getDerived().TransformType(E->getType()); 4971 if (T.isNull()) 4972 return SemaRef.ExprError(); 4973 4974 CXXConstructorDecl *Constructor 4975 = cast_or_null<CXXConstructorDecl>( 4976 getDerived().TransformDecl(E->getLocStart(), 4977 E->getConstructor())); 4978 if (!Constructor) 4979 return SemaRef.ExprError(); 4980 4981 bool ArgumentChanged = false; 4982 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 4983 for (CXXConstructExpr::arg_iterator Arg = E->arg_begin(), 4984 ArgEnd = E->arg_end(); 4985 Arg != ArgEnd; ++Arg) { 4986 if (getDerived().DropCallArgument(*Arg)) { 4987 ArgumentChanged = true; 4988 break; 4989 } 4990 4991 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 4992 if (TransArg.isInvalid()) 4993 return SemaRef.ExprError(); 4994 4995 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 4996 Args.push_back(TransArg.takeAs<Expr>()); 4997 } 4998 4999 if (!getDerived().AlwaysRebuild() && 5000 T == E->getType() && 5001 Constructor == E->getConstructor() && 5002 !ArgumentChanged) { 5003 // Mark the constructor as referenced. 5004 // FIXME: Instantiation-specific 5005 SemaRef.MarkDeclarationReferenced(E->getLocStart(), Constructor); 5006 return SemaRef.Owned(E->Retain()); 5007 } 5008 5009 return getDerived().RebuildCXXConstructExpr(T, /*FIXME:*/E->getLocStart(), 5010 Constructor, E->isElidable(), 5011 move_arg(Args)); 5012} 5013 5014/// \brief Transform a C++ temporary-binding expression. 5015/// 5016/// Since CXXBindTemporaryExpr nodes are implicitly generated, we just 5017/// transform the subexpression and return that. 5018template<typename Derived> 5019Sema::OwningExprResult 5020TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 5021 return getDerived().TransformExpr(E->getSubExpr()); 5022} 5023 5024/// \brief Transform a C++ reference-binding expression. 5025/// 5026/// Since CXXBindReferenceExpr nodes are implicitly generated, we just 5027/// transform the subexpression and return that. 5028template<typename Derived> 5029Sema::OwningExprResult 5030TreeTransform<Derived>::TransformCXXBindReferenceExpr(CXXBindReferenceExpr *E) { 5031 return getDerived().TransformExpr(E->getSubExpr()); 5032} 5033 5034/// \brief Transform a C++ expression that contains temporaries that should 5035/// be destroyed after the expression is evaluated. 5036/// 5037/// Since CXXExprWithTemporaries nodes are implicitly generated, we 5038/// just transform the subexpression and return that. 5039template<typename Derived> 5040Sema::OwningExprResult 5041TreeTransform<Derived>::TransformCXXExprWithTemporaries( 5042 CXXExprWithTemporaries *E) { 5043 return getDerived().TransformExpr(E->getSubExpr()); 5044} 5045 5046template<typename Derived> 5047Sema::OwningExprResult 5048TreeTransform<Derived>::TransformCXXTemporaryObjectExpr( 5049 CXXTemporaryObjectExpr *E) { 5050 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 5051 QualType T = getDerived().TransformType(E->getType()); 5052 if (T.isNull()) 5053 return SemaRef.ExprError(); 5054 5055 CXXConstructorDecl *Constructor 5056 = cast_or_null<CXXConstructorDecl>( 5057 getDerived().TransformDecl(E->getLocStart(), 5058 E->getConstructor())); 5059 if (!Constructor) 5060 return SemaRef.ExprError(); 5061 5062 bool ArgumentChanged = false; 5063 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 5064 Args.reserve(E->getNumArgs()); 5065 for (CXXTemporaryObjectExpr::arg_iterator Arg = E->arg_begin(), 5066 ArgEnd = E->arg_end(); 5067 Arg != ArgEnd; ++Arg) { 5068 if (getDerived().DropCallArgument(*Arg)) { 5069 ArgumentChanged = true; 5070 break; 5071 } 5072 5073 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 5074 if (TransArg.isInvalid()) 5075 return SemaRef.ExprError(); 5076 5077 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 5078 Args.push_back((Expr *)TransArg.release()); 5079 } 5080 5081 if (!getDerived().AlwaysRebuild() && 5082 T == E->getType() && 5083 Constructor == E->getConstructor() && 5084 !ArgumentChanged) { 5085 // FIXME: Instantiation-specific 5086 SemaRef.MarkDeclarationReferenced(E->getTypeBeginLoc(), Constructor); 5087 return SemaRef.Owned(E->Retain()); 5088 } 5089 5090 // FIXME: Bogus location information 5091 SourceLocation CommaLoc; 5092 if (Args.size() > 1) { 5093 Expr *First = (Expr *)Args[0]; 5094 CommaLoc 5095 = SemaRef.PP.getLocForEndOfToken(First->getSourceRange().getEnd()); 5096 } 5097 return getDerived().RebuildCXXTemporaryObjectExpr(E->getTypeBeginLoc(), 5098 T, 5099 /*FIXME:*/E->getTypeBeginLoc(), 5100 move_arg(Args), 5101 &CommaLoc, 5102 E->getLocEnd()); 5103} 5104 5105template<typename Derived> 5106Sema::OwningExprResult 5107TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( 5108 CXXUnresolvedConstructExpr *E) { 5109 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 5110 QualType T = getDerived().TransformType(E->getTypeAsWritten()); 5111 if (T.isNull()) 5112 return SemaRef.ExprError(); 5113 5114 bool ArgumentChanged = false; 5115 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 5116 llvm::SmallVector<SourceLocation, 8> FakeCommaLocs; 5117 for (CXXUnresolvedConstructExpr::arg_iterator Arg = E->arg_begin(), 5118 ArgEnd = E->arg_end(); 5119 Arg != ArgEnd; ++Arg) { 5120 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 5121 if (TransArg.isInvalid()) 5122 return SemaRef.ExprError(); 5123 5124 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 5125 FakeCommaLocs.push_back( 5126 SemaRef.PP.getLocForEndOfToken((*Arg)->getLocEnd())); 5127 Args.push_back(TransArg.takeAs<Expr>()); 5128 } 5129 5130 if (!getDerived().AlwaysRebuild() && 5131 T == E->getTypeAsWritten() && 5132 !ArgumentChanged) 5133 return SemaRef.Owned(E->Retain()); 5134 5135 // FIXME: we're faking the locations of the commas 5136 return getDerived().RebuildCXXUnresolvedConstructExpr(E->getTypeBeginLoc(), 5137 T, 5138 E->getLParenLoc(), 5139 move_arg(Args), 5140 FakeCommaLocs.data(), 5141 E->getRParenLoc()); 5142} 5143 5144template<typename Derived> 5145Sema::OwningExprResult 5146TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr( 5147 CXXDependentScopeMemberExpr *E) { 5148 // Transform the base of the expression. 5149 OwningExprResult Base(SemaRef, (Expr*) 0); 5150 Expr *OldBase; 5151 QualType BaseType; 5152 QualType ObjectType; 5153 if (!E->isImplicitAccess()) { 5154 OldBase = E->getBase(); 5155 Base = getDerived().TransformExpr(OldBase); 5156 if (Base.isInvalid()) 5157 return SemaRef.ExprError(); 5158 5159 // Start the member reference and compute the object's type. 5160 Sema::TypeTy *ObjectTy = 0; 5161 bool MayBePseudoDestructor = false; 5162 Base = SemaRef.ActOnStartCXXMemberReference(0, move(Base), 5163 E->getOperatorLoc(), 5164 E->isArrow()? tok::arrow : tok::period, 5165 ObjectTy, 5166 MayBePseudoDestructor); 5167 if (Base.isInvalid()) 5168 return SemaRef.ExprError(); 5169 5170 ObjectType = QualType::getFromOpaquePtr(ObjectTy); 5171 BaseType = ((Expr*) Base.get())->getType(); 5172 } else { 5173 OldBase = 0; 5174 BaseType = getDerived().TransformType(E->getBaseType()); 5175 ObjectType = BaseType->getAs<PointerType>()->getPointeeType(); 5176 } 5177 5178 // Transform the first part of the nested-name-specifier that qualifies 5179 // the member name. 5180 NamedDecl *FirstQualifierInScope 5181 = getDerived().TransformFirstQualifierInScope( 5182 E->getFirstQualifierFoundInScope(), 5183 E->getQualifierRange().getBegin()); 5184 5185 NestedNameSpecifier *Qualifier = 0; 5186 if (E->getQualifier()) { 5187 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 5188 E->getQualifierRange(), 5189 ObjectType, 5190 FirstQualifierInScope); 5191 if (!Qualifier) 5192 return SemaRef.ExprError(); 5193 } 5194 5195 DeclarationName Name 5196 = getDerived().TransformDeclarationName(E->getMember(), E->getMemberLoc(), 5197 ObjectType); 5198 if (!Name) 5199 return SemaRef.ExprError(); 5200 5201 if (!E->hasExplicitTemplateArgs()) { 5202 // This is a reference to a member without an explicitly-specified 5203 // template argument list. Optimize for this common case. 5204 if (!getDerived().AlwaysRebuild() && 5205 Base.get() == OldBase && 5206 BaseType == E->getBaseType() && 5207 Qualifier == E->getQualifier() && 5208 Name == E->getMember() && 5209 FirstQualifierInScope == E->getFirstQualifierFoundInScope()) 5210 return SemaRef.Owned(E->Retain()); 5211 5212 return getDerived().RebuildCXXDependentScopeMemberExpr(move(Base), 5213 BaseType, 5214 E->isArrow(), 5215 E->getOperatorLoc(), 5216 Qualifier, 5217 E->getQualifierRange(), 5218 FirstQualifierInScope, 5219 Name, 5220 E->getMemberLoc(), 5221 /*TemplateArgs*/ 0); 5222 } 5223 5224 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 5225 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 5226 TemplateArgumentLoc Loc; 5227 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc)) 5228 return SemaRef.ExprError(); 5229 TransArgs.addArgument(Loc); 5230 } 5231 5232 return getDerived().RebuildCXXDependentScopeMemberExpr(move(Base), 5233 BaseType, 5234 E->isArrow(), 5235 E->getOperatorLoc(), 5236 Qualifier, 5237 E->getQualifierRange(), 5238 FirstQualifierInScope, 5239 Name, 5240 E->getMemberLoc(), 5241 &TransArgs); 5242} 5243 5244template<typename Derived> 5245Sema::OwningExprResult 5246TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) { 5247 // Transform the base of the expression. 5248 OwningExprResult Base(SemaRef, (Expr*) 0); 5249 QualType BaseType; 5250 if (!Old->isImplicitAccess()) { 5251 Base = getDerived().TransformExpr(Old->getBase()); 5252 if (Base.isInvalid()) 5253 return SemaRef.ExprError(); 5254 BaseType = ((Expr*) Base.get())->getType(); 5255 } else { 5256 BaseType = getDerived().TransformType(Old->getBaseType()); 5257 } 5258 5259 NestedNameSpecifier *Qualifier = 0; 5260 if (Old->getQualifier()) { 5261 Qualifier 5262 = getDerived().TransformNestedNameSpecifier(Old->getQualifier(), 5263 Old->getQualifierRange()); 5264 if (Qualifier == 0) 5265 return SemaRef.ExprError(); 5266 } 5267 5268 LookupResult R(SemaRef, Old->getMemberName(), Old->getMemberLoc(), 5269 Sema::LookupOrdinaryName); 5270 5271 // Transform all the decls. 5272 for (UnresolvedMemberExpr::decls_iterator I = Old->decls_begin(), 5273 E = Old->decls_end(); I != E; ++I) { 5274 NamedDecl *InstD = static_cast<NamedDecl*>( 5275 getDerived().TransformDecl(Old->getMemberLoc(), 5276 *I)); 5277 if (!InstD) { 5278 // Silently ignore these if a UsingShadowDecl instantiated to nothing. 5279 // This can happen because of dependent hiding. 5280 if (isa<UsingShadowDecl>(*I)) 5281 continue; 5282 else 5283 return SemaRef.ExprError(); 5284 } 5285 5286 // Expand using declarations. 5287 if (isa<UsingDecl>(InstD)) { 5288 UsingDecl *UD = cast<UsingDecl>(InstD); 5289 for (UsingDecl::shadow_iterator I = UD->shadow_begin(), 5290 E = UD->shadow_end(); I != E; ++I) 5291 R.addDecl(*I); 5292 continue; 5293 } 5294 5295 R.addDecl(InstD); 5296 } 5297 5298 R.resolveKind(); 5299 5300 TemplateArgumentListInfo TransArgs; 5301 if (Old->hasExplicitTemplateArgs()) { 5302 TransArgs.setLAngleLoc(Old->getLAngleLoc()); 5303 TransArgs.setRAngleLoc(Old->getRAngleLoc()); 5304 for (unsigned I = 0, N = Old->getNumTemplateArgs(); I != N; ++I) { 5305 TemplateArgumentLoc Loc; 5306 if (getDerived().TransformTemplateArgument(Old->getTemplateArgs()[I], 5307 Loc)) 5308 return SemaRef.ExprError(); 5309 TransArgs.addArgument(Loc); 5310 } 5311 } 5312 5313 // FIXME: to do this check properly, we will need to preserve the 5314 // first-qualifier-in-scope here, just in case we had a dependent 5315 // base (and therefore couldn't do the check) and a 5316 // nested-name-qualifier (and therefore could do the lookup). 5317 NamedDecl *FirstQualifierInScope = 0; 5318 5319 return getDerived().RebuildUnresolvedMemberExpr(move(Base), 5320 BaseType, 5321 Old->getOperatorLoc(), 5322 Old->isArrow(), 5323 Qualifier, 5324 Old->getQualifierRange(), 5325 FirstQualifierInScope, 5326 R, 5327 (Old->hasExplicitTemplateArgs() 5328 ? &TransArgs : 0)); 5329} 5330 5331template<typename Derived> 5332Sema::OwningExprResult 5333TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) { 5334 return SemaRef.Owned(E->Retain()); 5335} 5336 5337template<typename Derived> 5338Sema::OwningExprResult 5339TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) { 5340 // FIXME: poor source location 5341 TemporaryBase Rebase(*this, E->getAtLoc(), DeclarationName()); 5342 QualType EncodedType = getDerived().TransformType(E->getEncodedType()); 5343 if (EncodedType.isNull()) 5344 return SemaRef.ExprError(); 5345 5346 if (!getDerived().AlwaysRebuild() && 5347 EncodedType == E->getEncodedType()) 5348 return SemaRef.Owned(E->Retain()); 5349 5350 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(), 5351 EncodedType, 5352 E->getRParenLoc()); 5353} 5354 5355template<typename Derived> 5356Sema::OwningExprResult 5357TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) { 5358 // FIXME: Implement this! 5359 assert(false && "Cannot transform Objective-C expressions yet"); 5360 return SemaRef.Owned(E->Retain()); 5361} 5362 5363template<typename Derived> 5364Sema::OwningExprResult 5365TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) { 5366 return SemaRef.Owned(E->Retain()); 5367} 5368 5369template<typename Derived> 5370Sema::OwningExprResult 5371TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) { 5372 ObjCProtocolDecl *Protocol 5373 = cast_or_null<ObjCProtocolDecl>( 5374 getDerived().TransformDecl(E->getLocStart(), 5375 E->getProtocol())); 5376 if (!Protocol) 5377 return SemaRef.ExprError(); 5378 5379 if (!getDerived().AlwaysRebuild() && 5380 Protocol == E->getProtocol()) 5381 return SemaRef.Owned(E->Retain()); 5382 5383 return getDerived().RebuildObjCProtocolExpr(Protocol, 5384 E->getAtLoc(), 5385 /*FIXME:*/E->getAtLoc(), 5386 /*FIXME:*/E->getAtLoc(), 5387 E->getRParenLoc()); 5388 5389} 5390 5391template<typename Derived> 5392Sema::OwningExprResult 5393TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) { 5394 // FIXME: Implement this! 5395 assert(false && "Cannot transform Objective-C expressions yet"); 5396 return SemaRef.Owned(E->Retain()); 5397} 5398 5399template<typename Derived> 5400Sema::OwningExprResult 5401TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 5402 // FIXME: Implement this! 5403 assert(false && "Cannot transform Objective-C expressions yet"); 5404 return SemaRef.Owned(E->Retain()); 5405} 5406 5407template<typename Derived> 5408Sema::OwningExprResult 5409TreeTransform<Derived>::TransformObjCImplicitSetterGetterRefExpr( 5410 ObjCImplicitSetterGetterRefExpr *E) { 5411 // FIXME: Implement this! 5412 assert(false && "Cannot transform Objective-C expressions yet"); 5413 return SemaRef.Owned(E->Retain()); 5414} 5415 5416template<typename Derived> 5417Sema::OwningExprResult 5418TreeTransform<Derived>::TransformObjCSuperExpr(ObjCSuperExpr *E) { 5419 // FIXME: Implement this! 5420 assert(false && "Cannot transform Objective-C expressions yet"); 5421 return SemaRef.Owned(E->Retain()); 5422} 5423 5424template<typename Derived> 5425Sema::OwningExprResult 5426TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) { 5427 // FIXME: Implement this! 5428 assert(false && "Cannot transform Objective-C expressions yet"); 5429 return SemaRef.Owned(E->Retain()); 5430} 5431 5432template<typename Derived> 5433Sema::OwningExprResult 5434TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) { 5435 bool ArgumentChanged = false; 5436 ASTOwningVector<&ActionBase::DeleteExpr> SubExprs(SemaRef); 5437 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) { 5438 OwningExprResult SubExpr = getDerived().TransformExpr(E->getExpr(I)); 5439 if (SubExpr.isInvalid()) 5440 return SemaRef.ExprError(); 5441 5442 ArgumentChanged = ArgumentChanged || SubExpr.get() != E->getExpr(I); 5443 SubExprs.push_back(SubExpr.takeAs<Expr>()); 5444 } 5445 5446 if (!getDerived().AlwaysRebuild() && 5447 !ArgumentChanged) 5448 return SemaRef.Owned(E->Retain()); 5449 5450 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(), 5451 move_arg(SubExprs), 5452 E->getRParenLoc()); 5453} 5454 5455template<typename Derived> 5456Sema::OwningExprResult 5457TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { 5458 // FIXME: Implement this! 5459 assert(false && "Cannot transform block expressions yet"); 5460 return SemaRef.Owned(E->Retain()); 5461} 5462 5463template<typename Derived> 5464Sema::OwningExprResult 5465TreeTransform<Derived>::TransformBlockDeclRefExpr(BlockDeclRefExpr *E) { 5466 // FIXME: Implement this! 5467 assert(false && "Cannot transform block-related expressions yet"); 5468 return SemaRef.Owned(E->Retain()); 5469} 5470 5471//===----------------------------------------------------------------------===// 5472// Type reconstruction 5473//===----------------------------------------------------------------------===// 5474 5475template<typename Derived> 5476QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType, 5477 SourceLocation Star) { 5478 return SemaRef.BuildPointerType(PointeeType, Qualifiers(), Star, 5479 getDerived().getBaseEntity()); 5480} 5481 5482template<typename Derived> 5483QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType, 5484 SourceLocation Star) { 5485 return SemaRef.BuildBlockPointerType(PointeeType, Qualifiers(), Star, 5486 getDerived().getBaseEntity()); 5487} 5488 5489template<typename Derived> 5490QualType 5491TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType, 5492 bool WrittenAsLValue, 5493 SourceLocation Sigil) { 5494 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue, Qualifiers(), 5495 Sigil, getDerived().getBaseEntity()); 5496} 5497 5498template<typename Derived> 5499QualType 5500TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType, 5501 QualType ClassType, 5502 SourceLocation Sigil) { 5503 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Qualifiers(), 5504 Sigil, getDerived().getBaseEntity()); 5505} 5506 5507template<typename Derived> 5508QualType 5509TreeTransform<Derived>::RebuildObjCObjectPointerType(QualType PointeeType, 5510 SourceLocation Sigil) { 5511 return SemaRef.BuildPointerType(PointeeType, Qualifiers(), Sigil, 5512 getDerived().getBaseEntity()); 5513} 5514 5515template<typename Derived> 5516QualType 5517TreeTransform<Derived>::RebuildArrayType(QualType ElementType, 5518 ArrayType::ArraySizeModifier SizeMod, 5519 const llvm::APInt *Size, 5520 Expr *SizeExpr, 5521 unsigned IndexTypeQuals, 5522 SourceRange BracketsRange) { 5523 if (SizeExpr || !Size) 5524 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr, 5525 IndexTypeQuals, BracketsRange, 5526 getDerived().getBaseEntity()); 5527 5528 QualType Types[] = { 5529 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy, 5530 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, 5531 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty 5532 }; 5533 const unsigned NumTypes = sizeof(Types) / sizeof(QualType); 5534 QualType SizeType; 5535 for (unsigned I = 0; I != NumTypes; ++I) 5536 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) { 5537 SizeType = Types[I]; 5538 break; 5539 } 5540 5541 IntegerLiteral ArraySize(*Size, SizeType, /*FIXME*/BracketsRange.getBegin()); 5542 return SemaRef.BuildArrayType(ElementType, SizeMod, &ArraySize, 5543 IndexTypeQuals, BracketsRange, 5544 getDerived().getBaseEntity()); 5545} 5546 5547template<typename Derived> 5548QualType 5549TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType, 5550 ArrayType::ArraySizeModifier SizeMod, 5551 const llvm::APInt &Size, 5552 unsigned IndexTypeQuals, 5553 SourceRange BracketsRange) { 5554 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0, 5555 IndexTypeQuals, BracketsRange); 5556} 5557 5558template<typename Derived> 5559QualType 5560TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType, 5561 ArrayType::ArraySizeModifier SizeMod, 5562 unsigned IndexTypeQuals, 5563 SourceRange BracketsRange) { 5564 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 0, 5565 IndexTypeQuals, BracketsRange); 5566} 5567 5568template<typename Derived> 5569QualType 5570TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType, 5571 ArrayType::ArraySizeModifier SizeMod, 5572 ExprArg SizeExpr, 5573 unsigned IndexTypeQuals, 5574 SourceRange BracketsRange) { 5575 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 5576 SizeExpr.takeAs<Expr>(), 5577 IndexTypeQuals, BracketsRange); 5578} 5579 5580template<typename Derived> 5581QualType 5582TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType, 5583 ArrayType::ArraySizeModifier SizeMod, 5584 ExprArg SizeExpr, 5585 unsigned IndexTypeQuals, 5586 SourceRange BracketsRange) { 5587 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 5588 SizeExpr.takeAs<Expr>(), 5589 IndexTypeQuals, BracketsRange); 5590} 5591 5592template<typename Derived> 5593QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType, 5594 unsigned NumElements, 5595 bool IsAltiVec, bool IsPixel) { 5596 // FIXME: semantic checking! 5597 return SemaRef.Context.getVectorType(ElementType, NumElements, 5598 IsAltiVec, IsPixel); 5599} 5600 5601template<typename Derived> 5602QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType, 5603 unsigned NumElements, 5604 SourceLocation AttributeLoc) { 5605 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy), 5606 NumElements, true); 5607 IntegerLiteral *VectorSize 5608 = new (SemaRef.Context) IntegerLiteral(numElements, SemaRef.Context.IntTy, 5609 AttributeLoc); 5610 return SemaRef.BuildExtVectorType(ElementType, SemaRef.Owned(VectorSize), 5611 AttributeLoc); 5612} 5613 5614template<typename Derived> 5615QualType 5616TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType, 5617 ExprArg SizeExpr, 5618 SourceLocation AttributeLoc) { 5619 return SemaRef.BuildExtVectorType(ElementType, move(SizeExpr), AttributeLoc); 5620} 5621 5622template<typename Derived> 5623QualType TreeTransform<Derived>::RebuildFunctionProtoType(QualType T, 5624 QualType *ParamTypes, 5625 unsigned NumParamTypes, 5626 bool Variadic, 5627 unsigned Quals) { 5628 return SemaRef.BuildFunctionType(T, ParamTypes, NumParamTypes, Variadic, 5629 Quals, 5630 getDerived().getBaseLocation(), 5631 getDerived().getBaseEntity()); 5632} 5633 5634template<typename Derived> 5635QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) { 5636 return SemaRef.Context.getFunctionNoProtoType(T); 5637} 5638 5639template<typename Derived> 5640QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(Decl *D) { 5641 assert(D && "no decl found"); 5642 if (D->isInvalidDecl()) return QualType(); 5643 5644 TypeDecl *Ty; 5645 if (isa<UsingDecl>(D)) { 5646 UsingDecl *Using = cast<UsingDecl>(D); 5647 assert(Using->isTypeName() && 5648 "UnresolvedUsingTypenameDecl transformed to non-typename using"); 5649 5650 // A valid resolved using typename decl points to exactly one type decl. 5651 assert(++Using->shadow_begin() == Using->shadow_end()); 5652 Ty = cast<TypeDecl>((*Using->shadow_begin())->getTargetDecl()); 5653 5654 } else { 5655 assert(isa<UnresolvedUsingTypenameDecl>(D) && 5656 "UnresolvedUsingTypenameDecl transformed to non-using decl"); 5657 Ty = cast<UnresolvedUsingTypenameDecl>(D); 5658 } 5659 5660 return SemaRef.Context.getTypeDeclType(Ty); 5661} 5662 5663template<typename Derived> 5664QualType TreeTransform<Derived>::RebuildTypeOfExprType(ExprArg E) { 5665 return SemaRef.BuildTypeofExprType(E.takeAs<Expr>()); 5666} 5667 5668template<typename Derived> 5669QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) { 5670 return SemaRef.Context.getTypeOfType(Underlying); 5671} 5672 5673template<typename Derived> 5674QualType TreeTransform<Derived>::RebuildDecltypeType(ExprArg E) { 5675 return SemaRef.BuildDecltypeType(E.takeAs<Expr>()); 5676} 5677 5678template<typename Derived> 5679QualType TreeTransform<Derived>::RebuildTemplateSpecializationType( 5680 TemplateName Template, 5681 SourceLocation TemplateNameLoc, 5682 const TemplateArgumentListInfo &TemplateArgs) { 5683 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs); 5684} 5685 5686template<typename Derived> 5687NestedNameSpecifier * 5688TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 5689 SourceRange Range, 5690 IdentifierInfo &II, 5691 QualType ObjectType, 5692 NamedDecl *FirstQualifierInScope) { 5693 CXXScopeSpec SS; 5694 // FIXME: The source location information is all wrong. 5695 SS.setRange(Range); 5696 SS.setScopeRep(Prefix); 5697 return static_cast<NestedNameSpecifier *>( 5698 SemaRef.BuildCXXNestedNameSpecifier(0, SS, Range.getEnd(), 5699 Range.getEnd(), II, 5700 ObjectType, 5701 FirstQualifierInScope, 5702 false, false)); 5703} 5704 5705template<typename Derived> 5706NestedNameSpecifier * 5707TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 5708 SourceRange Range, 5709 NamespaceDecl *NS) { 5710 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, NS); 5711} 5712 5713template<typename Derived> 5714NestedNameSpecifier * 5715TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 5716 SourceRange Range, 5717 bool TemplateKW, 5718 QualType T) { 5719 if (T->isDependentType() || T->isRecordType() || 5720 (SemaRef.getLangOptions().CPlusPlus0x && T->isEnumeralType())) { 5721 assert(!T.hasLocalQualifiers() && "Can't get cv-qualifiers here"); 5722 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, TemplateKW, 5723 T.getTypePtr()); 5724 } 5725 5726 SemaRef.Diag(Range.getBegin(), diag::err_nested_name_spec_non_tag) << T; 5727 return 0; 5728} 5729 5730template<typename Derived> 5731TemplateName 5732TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5733 bool TemplateKW, 5734 TemplateDecl *Template) { 5735 return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW, 5736 Template); 5737} 5738 5739template<typename Derived> 5740TemplateName 5741TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5742 const IdentifierInfo &II, 5743 QualType ObjectType) { 5744 CXXScopeSpec SS; 5745 SS.setRange(SourceRange(getDerived().getBaseLocation())); 5746 SS.setScopeRep(Qualifier); 5747 UnqualifiedId Name; 5748 Name.setIdentifier(&II, /*FIXME:*/getDerived().getBaseLocation()); 5749 return getSema().ActOnDependentTemplateName( 5750 /*FIXME:*/getDerived().getBaseLocation(), 5751 SS, 5752 Name, 5753 ObjectType.getAsOpaquePtr(), 5754 /*EnteringContext=*/false) 5755 .template getAsVal<TemplateName>(); 5756} 5757 5758template<typename Derived> 5759TemplateName 5760TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5761 OverloadedOperatorKind Operator, 5762 QualType ObjectType) { 5763 CXXScopeSpec SS; 5764 SS.setRange(SourceRange(getDerived().getBaseLocation())); 5765 SS.setScopeRep(Qualifier); 5766 UnqualifiedId Name; 5767 SourceLocation SymbolLocations[3]; // FIXME: Bogus location information. 5768 Name.setOperatorFunctionId(/*FIXME:*/getDerived().getBaseLocation(), 5769 Operator, SymbolLocations); 5770 return getSema().ActOnDependentTemplateName( 5771 /*FIXME:*/getDerived().getBaseLocation(), 5772 SS, 5773 Name, 5774 ObjectType.getAsOpaquePtr(), 5775 /*EnteringContext=*/false) 5776 .template getAsVal<TemplateName>(); 5777} 5778 5779template<typename Derived> 5780Sema::OwningExprResult 5781TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, 5782 SourceLocation OpLoc, 5783 ExprArg Callee, 5784 ExprArg First, 5785 ExprArg Second) { 5786 Expr *FirstExpr = (Expr *)First.get(); 5787 Expr *SecondExpr = (Expr *)Second.get(); 5788 Expr *CalleeExpr = ((Expr *)Callee.get())->IgnoreParenCasts(); 5789 bool isPostIncDec = SecondExpr && (Op == OO_PlusPlus || Op == OO_MinusMinus); 5790 5791 // Determine whether this should be a builtin operation. 5792 if (Op == OO_Subscript) { 5793 if (!FirstExpr->getType()->isOverloadableType() && 5794 !SecondExpr->getType()->isOverloadableType()) 5795 return getSema().CreateBuiltinArraySubscriptExpr(move(First), 5796 CalleeExpr->getLocStart(), 5797 move(Second), OpLoc); 5798 } else if (Op == OO_Arrow) { 5799 // -> is never a builtin operation. 5800 return SemaRef.BuildOverloadedArrowExpr(0, move(First), OpLoc); 5801 } else if (SecondExpr == 0 || isPostIncDec) { 5802 if (!FirstExpr->getType()->isOverloadableType()) { 5803 // The argument is not of overloadable type, so try to create a 5804 // built-in unary operation. 5805 UnaryOperator::Opcode Opc 5806 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 5807 5808 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, move(First)); 5809 } 5810 } else { 5811 if (!FirstExpr->getType()->isOverloadableType() && 5812 !SecondExpr->getType()->isOverloadableType()) { 5813 // Neither of the arguments is an overloadable type, so try to 5814 // create a built-in binary operation. 5815 BinaryOperator::Opcode Opc = BinaryOperator::getOverloadedOpcode(Op); 5816 OwningExprResult Result 5817 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, FirstExpr, SecondExpr); 5818 if (Result.isInvalid()) 5819 return SemaRef.ExprError(); 5820 5821 First.release(); 5822 Second.release(); 5823 return move(Result); 5824 } 5825 } 5826 5827 // Compute the transformed set of functions (and function templates) to be 5828 // used during overload resolution. 5829 UnresolvedSet<16> Functions; 5830 5831 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(CalleeExpr)) { 5832 assert(ULE->requiresADL()); 5833 5834 // FIXME: Do we have to check 5835 // IsAcceptableNonMemberOperatorCandidate for each of these? 5836 Functions.append(ULE->decls_begin(), ULE->decls_end()); 5837 } else { 5838 Functions.addDecl(cast<DeclRefExpr>(CalleeExpr)->getDecl()); 5839 } 5840 5841 // Add any functions found via argument-dependent lookup. 5842 Expr *Args[2] = { FirstExpr, SecondExpr }; 5843 unsigned NumArgs = 1 + (SecondExpr != 0); 5844 5845 // Create the overloaded operator invocation for unary operators. 5846 if (NumArgs == 1 || isPostIncDec) { 5847 UnaryOperator::Opcode Opc 5848 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 5849 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, move(First)); 5850 } 5851 5852 if (Op == OO_Subscript) 5853 return SemaRef.CreateOverloadedArraySubscriptExpr(CalleeExpr->getLocStart(), 5854 OpLoc, 5855 move(First), 5856 move(Second)); 5857 5858 // Create the overloaded operator invocation for binary operators. 5859 BinaryOperator::Opcode Opc = 5860 BinaryOperator::getOverloadedOpcode(Op); 5861 OwningExprResult Result 5862 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]); 5863 if (Result.isInvalid()) 5864 return SemaRef.ExprError(); 5865 5866 First.release(); 5867 Second.release(); 5868 return move(Result); 5869} 5870 5871template<typename Derived> 5872Sema::OwningExprResult 5873TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(ExprArg Base, 5874 SourceLocation OperatorLoc, 5875 bool isArrow, 5876 NestedNameSpecifier *Qualifier, 5877 SourceRange QualifierRange, 5878 TypeSourceInfo *ScopeType, 5879 SourceLocation CCLoc, 5880 SourceLocation TildeLoc, 5881 PseudoDestructorTypeStorage Destroyed) { 5882 CXXScopeSpec SS; 5883 if (Qualifier) { 5884 SS.setRange(QualifierRange); 5885 SS.setScopeRep(Qualifier); 5886 } 5887 5888 Expr *BaseE = (Expr *)Base.get(); 5889 QualType BaseType = BaseE->getType(); 5890 if (BaseE->isTypeDependent() || Destroyed.getIdentifier() || 5891 (!isArrow && !BaseType->getAs<RecordType>()) || 5892 (isArrow && BaseType->getAs<PointerType>() && 5893 !BaseType->getAs<PointerType>()->getPointeeType() 5894 ->template getAs<RecordType>())){ 5895 // This pseudo-destructor expression is still a pseudo-destructor. 5896 return SemaRef.BuildPseudoDestructorExpr(move(Base), OperatorLoc, 5897 isArrow? tok::arrow : tok::period, 5898 SS, ScopeType, CCLoc, TildeLoc, 5899 Destroyed, 5900 /*FIXME?*/true); 5901 } 5902 5903 TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo(); 5904 DeclarationName Name 5905 = SemaRef.Context.DeclarationNames.getCXXDestructorName( 5906 SemaRef.Context.getCanonicalType(DestroyedType->getType())); 5907 5908 // FIXME: the ScopeType should be tacked onto SS. 5909 5910 return getSema().BuildMemberReferenceExpr(move(Base), BaseType, 5911 OperatorLoc, isArrow, 5912 SS, /*FIXME: FirstQualifier*/ 0, 5913 Name, Destroyed.getLocation(), 5914 /*TemplateArgs*/ 0); 5915} 5916 5917} // end namespace clang 5918 5919#endif // LLVM_CLANG_SEMA_TREETRANSFORM_H 5920