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