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