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