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