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