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