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