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