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