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