TreeTransform.h revision 1bb8a45f7386a23871598d05141a07af03067925
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/Expr.h" 19#include "clang/AST/ExprCXX.h" 20#include "clang/AST/ExprObjC.h" 21#include "clang/Parse/Ownership.h" 22#include "clang/Parse/Designator.h" 23#include "clang/Lex/Preprocessor.h" 24#include <algorithm> 25 26namespace clang { 27 28/// \brief A semantic tree transformation that allows one to transform one 29/// abstract syntax tree into another. 30/// 31/// A new tree transformation is defined by creating a new subclass \c X of 32/// \c TreeTransform<X> and then overriding certain operations to provide 33/// behavior specific to that transformation. For example, template 34/// instantiation is implemented as a tree transformation where the 35/// transformation of TemplateTypeParmType nodes involves substituting the 36/// template arguments for their corresponding template parameters; a similar 37/// transformation is performed for non-type template parameters and 38/// template template parameters. 39/// 40/// This tree-transformation template uses static polymorphism to allow 41/// subclasses to customize any of its operations. Thus, a subclass can 42/// override any of the transformation or rebuild operators by providing an 43/// operation with the same signature as the default implementation. The 44/// overridding function should not be virtual. 45/// 46/// Semantic tree transformations are split into two stages, either of which 47/// can be replaced by a subclass. The "transform" step transforms an AST node 48/// or the parts of an AST node using the various transformation functions, 49/// then passes the pieces on to the "rebuild" step, which constructs a new AST 50/// node of the appropriate kind from the pieces. The default transformation 51/// routines recursively transform the operands to composite AST nodes (e.g., 52/// the pointee type of a PointerType node) and, if any of those operand nodes 53/// were changed by the transformation, invokes the rebuild operation to create 54/// a new AST node. 55/// 56/// Subclasses can customize the transformation at various levels. The 57/// most coarse-grained transformations involve replacing TransformType(), 58/// TransformExpr(), TransformDecl(), TransformNestedNameSpecifier(), 59/// TransformTemplateName(), or TransformTemplateArgument() with entirely 60/// new implementations. 61/// 62/// For more fine-grained transformations, subclasses can replace any of the 63/// \c TransformXXX functions (where XXX is the name of an AST node, e.g., 64/// PointerType) to alter the transformation. As mentioned previously, 65/// replacing TransformTemplateTypeParmType() allows template instantiation 66/// to substitute template arguments for their corresponding template 67/// parameters. Additionally, subclasses can override the \c RebuildXXX 68/// functions to control how AST nodes are rebuilt when their operands change. 69/// By default, \c TreeTransform will invoke semantic analysis to rebuild 70/// AST nodes. However, certain other tree transformations (e.g, cloning) may 71/// be able to use more efficient rebuild steps. 72/// 73/// There are a handful of other functions that can be overridden, allowing one 74/// to avoid traversing nodes that don't need any transformation 75/// (\c AlreadyTransformed()), force rebuilding AST nodes even when their 76/// operands have not changed (\c AlwaysRebuild()), and customize the 77/// default locations and entity names used for type-checking 78/// (\c getBaseLocation(), \c getBaseEntity()). 79/// 80/// FIXME: In the future, TreeTransform will support transformation of 81/// statements and expressions as well as types. 82template<typename Derived> 83class TreeTransform { 84protected: 85 Sema &SemaRef; 86 87public: 88 typedef Sema::OwningStmtResult OwningStmtResult; 89 typedef Sema::OwningExprResult OwningExprResult; 90 typedef Sema::StmtArg StmtArg; 91 typedef Sema::ExprArg ExprArg; 92 typedef Sema::MultiExprArg MultiExprArg; 93 94 /// \brief Initializes a new tree transformer. 95 TreeTransform(Sema &SemaRef) : SemaRef(SemaRef) { } 96 97 /// \brief Retrieves a reference to the derived class. 98 Derived &getDerived() { return static_cast<Derived&>(*this); } 99 100 /// \brief Retrieves a reference to the derived class. 101 const Derived &getDerived() const { 102 return static_cast<const Derived&>(*this); 103 } 104 105 /// \brief Retrieves a reference to the semantic analysis object used for 106 /// this tree transform. 107 Sema &getSema() const { return SemaRef; } 108 109 /// \brief Whether the transformation should always rebuild AST nodes, even 110 /// if none of the children have changed. 111 /// 112 /// Subclasses may override this function to specify when the transformation 113 /// should rebuild all AST nodes. 114 bool AlwaysRebuild() { return false; } 115 116 /// \brief Returns the location of the entity being transformed, if that 117 /// information was not available elsewhere in the AST. 118 /// 119 /// By default, returns no source-location information. Subclasses can 120 /// provide an alternative implementation that provides better location 121 /// information. 122 SourceLocation getBaseLocation() { return SourceLocation(); } 123 124 /// \brief Returns the name of the entity being transformed, if that 125 /// information was not available elsewhere in the AST. 126 /// 127 /// By default, returns an empty name. Subclasses can provide an alternative 128 /// implementation with a more precise name. 129 DeclarationName getBaseEntity() { return DeclarationName(); } 130 131 /// \brief Sets the "base" location and entity when that 132 /// information is known based on another transformation. 133 /// 134 /// By default, the source location and entity are ignored. Subclasses can 135 /// override this function to provide a customized implementation. 136 void setBase(SourceLocation Loc, DeclarationName Entity) { } 137 138 /// \brief RAII object that temporarily sets the base location and entity 139 /// used for reporting diagnostics in types. 140 class TemporaryBase { 141 TreeTransform &Self; 142 SourceLocation OldLocation; 143 DeclarationName OldEntity; 144 145 public: 146 TemporaryBase(TreeTransform &Self, SourceLocation Location, 147 DeclarationName Entity) : Self(Self) 148 { 149 OldLocation = Self.getDerived().getBaseLocation(); 150 OldEntity = Self.getDerived().getBaseEntity(); 151 Self.getDerived().setBase(Location, Entity); 152 } 153 154 ~TemporaryBase() { 155 Self.getDerived().setBase(OldLocation, OldEntity); 156 } 157 }; 158 159 /// \brief Determine whether the given type \p T has already been 160 /// transformed. 161 /// 162 /// Subclasses can provide an alternative implementation of this routine 163 /// to short-circuit evaluation when it is known that a given type will 164 /// not change. For example, template instantiation need not traverse 165 /// non-dependent types. 166 bool AlreadyTransformed(QualType T) { 167 return T.isNull(); 168 } 169 170 /// \brief Transforms the given type into another type. 171 /// 172 /// By default, this routine transforms a type by delegating to the 173 /// appropriate TransformXXXType to build a new type, then applying 174 /// the qualifiers on \p T to the resulting type with AddTypeQualifiers. 175 /// Subclasses may override this function (to take over all type 176 /// transformations), some set of the TransformXXXType functions, or 177 /// the AddTypeQualifiers function to alter the transformation. 178 /// 179 /// \returns the transformed type. 180 QualType TransformType(QualType T); 181 182 /// \brief Transform the given type by adding the given set of qualifiers 183 /// and returning the result. 184 /// 185 /// FIXME: By default, this routine adds type qualifiers only to types that 186 /// can have qualifiers, and silently suppresses those qualifiers that are 187 /// not permitted (e.g., qualifiers on reference or function types). This 188 /// is the right thing for template instantiation, but probably not for 189 /// other clients. 190 QualType AddTypeQualifiers(QualType T, unsigned CVRQualifiers); 191 192 /// \brief Transform the given statement. 193 /// 194 /// FIXME: At the moment, subclasses must override this. 195 OwningStmtResult TransformStmt(Stmt *S); 196 197 /// \brief Transform the given expression. 198 /// 199 /// By default, this routine transforms an expression by delegating to the 200 /// appropriate TransformXXXExpr function to build a new expression. 201 /// Subclasses may override this function to transform expressions using some 202 /// other mechanism. 203 /// 204 /// \returns the transformed expression. 205 OwningExprResult TransformExpr(Expr *E) { 206 return getDerived().TransformExpr(E, /*isAddressOfOperand=*/false); 207 } 208 209 /// \brief Transform the given expression. 210 /// 211 /// By default, this routine transforms an expression by delegating to the 212 /// appropriate TransformXXXExpr function to build a new expression. 213 /// Subclasses may override this function to transform expressions using some 214 /// other mechanism. 215 /// 216 /// \returns the transformed expression. 217 OwningExprResult TransformExpr(Expr *E, bool isAddressOfOperand); 218 219 /// \brief Transform the given declaration, which is referenced from a type 220 /// or expression. 221 /// 222 /// By default, acts as the identity function on declarations. Subclasses 223 /// may override this function to provide alternate behavior. 224 Decl *TransformDecl(Decl *D) { return D; } 225 226 /// \brief Transform the given nested-name-specifier. 227 /// 228 /// By default, transforms all of the types and declarations within the 229 /// nested-name-specifier. Subclasses may override this function to provide 230 /// alternate behavior. 231 NestedNameSpecifier *TransformNestedNameSpecifier(NestedNameSpecifier *NNS, 232 SourceRange Range); 233 234 /// \brief Transform the given template name. 235 /// 236 /// By default, transforms the template name by transforming the declarations 237 /// and nested-name-specifiers that occur within the template name. 238 /// Subclasses may override this function to provide alternate behavior. 239 TemplateName TransformTemplateName(TemplateName Name); 240 241 /// \brief Transform the given template argument. 242 /// 243 /// By default, this operation transforms the type, expression, or 244 /// declaration stored within the template argument and constructs a 245 /// new template argument from the transformed result. Subclasses may 246 /// override this function to provide alternate behavior. 247 TemplateArgument TransformTemplateArgument(const TemplateArgument &Arg); 248 249#define ABSTRACT_TYPE(CLASS, PARENT) 250#define TYPE(CLASS, PARENT) \ 251 QualType Transform##CLASS##Type(const CLASS##Type *T); 252#include "clang/AST/TypeNodes.def" 253 254 OwningStmtResult TransformCompoundStmt(Stmt *S, bool IsStmtExpr) { 255 // FIXME: Actually handle this transformation properly. 256 return getDerived().TransformStmt(S); 257 } 258 259#define STMT(Node, Parent) 260#define EXPR(Node, Parent) \ 261 OwningExprResult Transform##Node(Node *E); 262#define ABSTRACT_EXPR(Node, Parent) 263#include "clang/AST/StmtNodes.def" 264 265 /// \brief Build a new pointer type given its pointee type. 266 /// 267 /// By default, performs semantic analysis when building the pointer type. 268 /// Subclasses may override this routine to provide different behavior. 269 QualType RebuildPointerType(QualType PointeeType); 270 271 /// \brief Build a new block pointer type given its pointee type. 272 /// 273 /// By default, performs semantic analysis when building the block pointer 274 /// type. Subclasses may override this routine to provide different behavior. 275 QualType RebuildBlockPointerType(QualType PointeeType); 276 277 /// \brief Build a new lvalue reference type given the type it references. 278 /// 279 /// By default, performs semantic analysis when building the lvalue reference 280 /// type. Subclasses may override this routine to provide different behavior. 281 QualType RebuildLValueReferenceType(QualType ReferentType); 282 283 /// \brief Build a new rvalue reference type given the type it references. 284 /// 285 /// By default, performs semantic analysis when building the rvalue reference 286 /// type. Subclasses may override this routine to provide different behavior. 287 QualType RebuildRValueReferenceType(QualType ReferentType); 288 289 /// \brief Build a new member pointer type given the pointee type and the 290 /// class type it refers into. 291 /// 292 /// By default, performs semantic analysis when building the member pointer 293 /// type. Subclasses may override this routine to provide different behavior. 294 QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType); 295 296 /// \brief Build a new array type given the element type, size 297 /// modifier, size of the array (if known), size expression, and index type 298 /// qualifiers. 299 /// 300 /// By default, performs semantic analysis when building the array type. 301 /// Subclasses may override this routine to provide different behavior. 302 /// Also by default, all of the other Rebuild*Array 303 QualType RebuildArrayType(QualType ElementType, 304 ArrayType::ArraySizeModifier SizeMod, 305 const llvm::APInt *Size, 306 Expr *SizeExpr, 307 unsigned IndexTypeQuals, 308 SourceRange BracketsRange); 309 310 /// \brief Build a new constant array type given the element type, size 311 /// modifier, (known) size of the array, and index type qualifiers. 312 /// 313 /// By default, performs semantic analysis when building the array type. 314 /// Subclasses may override this routine to provide different behavior. 315 QualType RebuildConstantArrayType(QualType ElementType, 316 ArrayType::ArraySizeModifier SizeMod, 317 const llvm::APInt &Size, 318 unsigned IndexTypeQuals); 319 320 /// \brief Build a new constant array type given the element type, size 321 /// modifier, (known) size of the array, size expression, and index type 322 /// qualifiers. 323 /// 324 /// By default, performs semantic analysis when building the array type. 325 /// Subclasses may override this routine to provide different behavior. 326 QualType RebuildConstantArrayWithExprType(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 RebuildConstantArrayWithoutExprType(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 typeof(expr) type. 423 /// 424 /// By default, performs semantic analysis when building the typeof type. 425 /// Subclasses may override this routine to provide different behavior. 426 QualType RebuildTypeOfExprType(ExprArg Underlying); 427 428 /// \brief Build a new typeof(type) type. 429 /// 430 /// By default, builds a new TypeOfType with the given underlying type. 431 QualType RebuildTypeOfType(QualType Underlying); 432 433 /// \brief Build a new C++0x decltype type. 434 /// 435 /// By default, performs semantic analysis when building the decltype type. 436 /// Subclasses may override this routine to provide different behavior. 437 QualType RebuildDecltypeType(ExprArg Underlying); 438 439 /// \brief Build a new template specialization type. 440 /// 441 /// By default, performs semantic analysis when building the template 442 /// specialization type. Subclasses may override this routine to provide 443 /// different behavior. 444 QualType RebuildTemplateSpecializationType(TemplateName Template, 445 const TemplateArgument *Args, 446 unsigned NumArgs); 447 448 /// \brief Build a new qualified name type. 449 /// 450 /// By default, builds a new QualifiedNameType type from the 451 /// nested-name-specifier and the named type. Subclasses may override 452 /// this routine to provide different behavior. 453 QualType RebuildQualifiedNameType(NestedNameSpecifier *NNS, QualType Named) { 454 return SemaRef.Context.getQualifiedNameType(NNS, Named); 455 } 456 457 /// \brief Build a new typename type that refers to a template-id. 458 /// 459 /// By default, builds a new TypenameType type from the nested-name-specifier 460 /// and the given type. Subclasses may override this routine to provide 461 /// different behavior. 462 QualType RebuildTypenameType(NestedNameSpecifier *NNS, QualType T) { 463 if (NNS->isDependent()) 464 return SemaRef.Context.getTypenameType(NNS, 465 cast<TemplateSpecializationType>(T)); 466 467 return SemaRef.Context.getQualifiedNameType(NNS, T); 468 } 469 470 /// \brief Build a new typename type that refers to an identifier. 471 /// 472 /// By default, performs semantic analysis when building the typename type 473 /// (or qualified name type). Subclasses may override this routine to provide 474 /// different behavior. 475 QualType RebuildTypenameType(NestedNameSpecifier *NNS, 476 const IdentifierInfo *Id) { 477 return SemaRef.CheckTypenameType(NNS, *Id, 478 SourceRange(getDerived().getBaseLocation())); 479 } 480 481 /// \brief Build a new nested-name-specifier given the prefix and an 482 /// identifier that names the next step in the nested-name-specifier. 483 /// 484 /// By default, performs semantic analysis when building the new 485 /// nested-name-specifier. Subclasses may override this routine to provide 486 /// different behavior. 487 NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 488 SourceRange Range, 489 IdentifierInfo &II); 490 491 /// \brief Build a new nested-name-specifier given the prefix and the 492 /// namespace named in the next step in the nested-name-specifier. 493 /// 494 /// By default, performs semantic analysis when building the new 495 /// nested-name-specifier. Subclasses may override this routine to provide 496 /// different behavior. 497 NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 498 SourceRange Range, 499 NamespaceDecl *NS); 500 501 /// \brief Build a new nested-name-specifier given the prefix and the 502 /// type named in the next step in the nested-name-specifier. 503 /// 504 /// By default, performs semantic analysis when building the new 505 /// nested-name-specifier. Subclasses may override this routine to provide 506 /// different behavior. 507 NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 508 SourceRange Range, 509 bool TemplateKW, 510 QualType T); 511 512 /// \brief Build a new template name given a nested name specifier, a flag 513 /// indicating whether the "template" keyword was provided, and the template 514 /// that the template name refers to. 515 /// 516 /// By default, builds the new template name directly. Subclasses may override 517 /// this routine to provide different behavior. 518 TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier, 519 bool TemplateKW, 520 TemplateDecl *Template); 521 522 /// \brief Build a new template name given a nested name specifier, a flag 523 /// indicating whether the "template" keyword was provided, and a set of 524 /// overloaded function templates. 525 /// 526 /// By default, builds the new template name directly. Subclasses may override 527 /// this routine to provide different behavior. 528 TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier, 529 bool TemplateKW, 530 OverloadedFunctionDecl *Ovl); 531 532 /// \brief Build a new template name given a nested name specifier and the 533 /// name that is referred to as a template. 534 /// 535 /// By default, performs semantic analysis to determine whether the name can 536 /// be resolved to a specific template, then builds the appropriate kind of 537 /// template name. Subclasses may override this routine to provide different 538 /// behavior. 539 TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier, 540 const IdentifierInfo &II); 541 542 543 /// \brief Build a new expression that references a declaration. 544 /// 545 /// By default, performs semantic analysis to build the new expression. 546 /// Subclasses may override this routine to provide different behavior. 547 OwningExprResult RebuildDeclRefExpr(NamedDecl *ND, SourceLocation Loc) { 548 return getSema().BuildDeclarationNameExpr(Loc, ND, 549 /*FIXME:*/false, 550 /*SS=*/0, 551 /*FIXME:*/false); 552 } 553 554 /// \brief Build a new expression in parentheses. 555 /// 556 /// By default, performs semantic analysis to build the new expression. 557 /// Subclasses may override this routine to provide different behavior. 558 OwningExprResult RebuildParenExpr(ExprArg SubExpr, SourceLocation LParen, 559 SourceLocation RParen) { 560 return getSema().ActOnParenExpr(LParen, RParen, move(SubExpr)); 561 } 562 563 /// \brief Build a new unary operator expression. 564 /// 565 /// By default, performs semantic analysis to build the new expression. 566 /// Subclasses may override this routine to provide different behavior. 567 OwningExprResult RebuildUnaryOperator(SourceLocation OpLoc, 568 UnaryOperator::Opcode Opc, 569 ExprArg SubExpr) { 570 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, move(SubExpr)); 571 } 572 573 /// \brief Build a new sizeof or alignof expression with a type argument. 574 /// 575 /// By default, performs semantic analysis to build the new expression. 576 /// Subclasses may override this routine to provide different behavior. 577 OwningExprResult RebuildSizeOfAlignOf(QualType T, SourceLocation OpLoc, 578 bool isSizeOf, SourceRange R) { 579 return getSema().CreateSizeOfAlignOfExpr(T, OpLoc, isSizeOf, R); 580 } 581 582 /// \brief Build a new sizeof or alignof expression with an expression 583 /// argument. 584 /// 585 /// By default, performs semantic analysis to build the new expression. 586 /// Subclasses may override this routine to provide different behavior. 587 OwningExprResult RebuildSizeOfAlignOf(ExprArg SubExpr, SourceLocation OpLoc, 588 bool isSizeOf, SourceRange R) { 589 OwningExprResult Result 590 = getSema().CreateSizeOfAlignOfExpr((Expr *)SubExpr.get(), 591 OpLoc, isSizeOf, R); 592 if (Result.isInvalid()) 593 return getSema().ExprError(); 594 595 SubExpr.release(); 596 return move(Result); 597 } 598 599 /// \brief Build a new array subscript expression. 600 /// 601 /// By default, performs semantic analysis to build the new expression. 602 /// Subclasses may override this routine to provide different behavior. 603 OwningExprResult RebuildArraySubscriptExpr(ExprArg LHS, 604 SourceLocation LBracketLoc, 605 ExprArg RHS, 606 SourceLocation RBracketLoc) { 607 return getSema().ActOnArraySubscriptExpr(/*Scope=*/0, move(LHS), 608 LBracketLoc, move(RHS), 609 RBracketLoc); 610 } 611 612 /// \brief Build a new call expression. 613 /// 614 /// By default, performs semantic analysis to build the new expression. 615 /// Subclasses may override this routine to provide different behavior. 616 OwningExprResult RebuildCallExpr(ExprArg Callee, SourceLocation LParenLoc, 617 MultiExprArg Args, 618 SourceLocation *CommaLocs, 619 SourceLocation RParenLoc) { 620 return getSema().ActOnCallExpr(/*Scope=*/0, move(Callee), LParenLoc, 621 move(Args), CommaLocs, RParenLoc); 622 } 623 624 /// \brief Build a new member access expression. 625 /// 626 /// By default, performs semantic analysis to build the new expression. 627 /// Subclasses may override this routine to provide different behavior. 628 OwningExprResult RebuildMemberExpr(ExprArg Base, SourceLocation OpLoc, 629 bool isArrow, SourceLocation MemberLoc, 630 NamedDecl *Member) { 631 return getSema().ActOnMemberReferenceExpr(/*Scope=*/0, move(Base), OpLoc, 632 isArrow? tok::arrow : tok::period, 633 MemberLoc, 634 /*FIXME*/*Member->getIdentifier(), 635 /*FIXME?*/Sema::DeclPtrTy::make((Decl*)0)); 636 } 637 638 /// \brief Build a new binary operator expression. 639 /// 640 /// By default, performs semantic analysis to build the new expression. 641 /// Subclasses may override this routine to provide different behavior. 642 OwningExprResult RebuildBinaryOperator(SourceLocation OpLoc, 643 BinaryOperator::Opcode Opc, 644 ExprArg LHS, ExprArg RHS) { 645 OwningExprResult Result 646 = getSema().CreateBuiltinBinOp(OpLoc, Opc, (Expr *)LHS.get(), 647 (Expr *)RHS.get()); 648 if (Result.isInvalid()) 649 return SemaRef.ExprError(); 650 651 LHS.release(); 652 RHS.release(); 653 return move(Result); 654 } 655 656 /// \brief Build a new conditional operator expression. 657 /// 658 /// By default, performs semantic analysis to build the new expression. 659 /// Subclasses may override this routine to provide different behavior. 660 OwningExprResult RebuildConditionalOperator(ExprArg Cond, 661 SourceLocation QuestionLoc, 662 ExprArg LHS, 663 SourceLocation ColonLoc, 664 ExprArg RHS) { 665 return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, move(Cond), 666 move(LHS), move(RHS)); 667 } 668 669 /// \brief Build a new implicit cast expression. 670 /// 671 /// By default, builds a new implicit cast without any semantic analysis. 672 /// Subclasses may override this routine to provide different behavior. 673 OwningExprResult RebuildImplicitCastExpr(QualType T, CastExpr::CastKind Kind, 674 ExprArg SubExpr, bool isLvalue) { 675 ImplicitCastExpr *ICE 676 = new (getSema().Context) ImplicitCastExpr(T, Kind, 677 (Expr *)SubExpr.release(), 678 isLvalue); 679 return getSema().Owned(ICE); 680 } 681 682 /// \brief Build a new C-style cast expression. 683 /// 684 /// By default, performs semantic analysis to build the new expression. 685 /// Subclasses may override this routine to provide different behavior. 686 OwningExprResult RebuildCStyleCaseExpr(SourceLocation LParenLoc, 687 QualType ExplicitTy, 688 SourceLocation RParenLoc, 689 ExprArg SubExpr) { 690 return getSema().ActOnCastExpr(/*Scope=*/0, 691 LParenLoc, 692 ExplicitTy.getAsOpaquePtr(), 693 RParenLoc, 694 move(SubExpr)); 695 } 696 697 /// \brief Build a new compound literal expression. 698 /// 699 /// By default, performs semantic analysis to build the new expression. 700 /// Subclasses may override this routine to provide different behavior. 701 OwningExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc, 702 QualType T, 703 SourceLocation RParenLoc, 704 ExprArg Init) { 705 return getSema().ActOnCompoundLiteral(LParenLoc, T.getAsOpaquePtr(), 706 RParenLoc, move(Init)); 707 } 708 709 /// \brief Build a new extended vector element access expression. 710 /// 711 /// By default, performs semantic analysis to build the new expression. 712 /// Subclasses may override this routine to provide different behavior. 713 OwningExprResult RebuildExtVectorElementExpr(ExprArg Base, 714 SourceLocation OpLoc, 715 SourceLocation AccessorLoc, 716 IdentifierInfo &Accessor) { 717 return getSema().ActOnMemberReferenceExpr(/*Scope=*/0, move(Base), OpLoc, 718 tok::period, AccessorLoc, 719 Accessor, 720 /*FIXME?*/Sema::DeclPtrTy::make((Decl*)0)); 721 } 722 723 /// \brief Build a new initializer list expression. 724 /// 725 /// By default, performs semantic analysis to build the new expression. 726 /// Subclasses may override this routine to provide different behavior. 727 OwningExprResult RebuildInitList(SourceLocation LBraceLoc, 728 MultiExprArg Inits, 729 SourceLocation RBraceLoc) { 730 return SemaRef.ActOnInitList(LBraceLoc, move(Inits), RBraceLoc); 731 } 732 733 /// \brief Build a new designated initializer expression. 734 /// 735 /// By default, performs semantic analysis to build the new expression. 736 /// Subclasses may override this routine to provide different behavior. 737 OwningExprResult RebuildDesignatedInitExpr(Designation &Desig, 738 MultiExprArg ArrayExprs, 739 SourceLocation EqualOrColonLoc, 740 bool GNUSyntax, 741 ExprArg Init) { 742 OwningExprResult Result 743 = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax, 744 move(Init)); 745 if (Result.isInvalid()) 746 return SemaRef.ExprError(); 747 748 ArrayExprs.release(); 749 return move(Result); 750 } 751 752 /// \brief Build a new value-initialized expression. 753 /// 754 /// By default, builds the implicit value initialization without performing 755 /// any semantic analysis. Subclasses may override this routine to provide 756 /// different behavior. 757 OwningExprResult RebuildImplicitValueInitExpr(QualType T) { 758 return SemaRef.Owned(new (SemaRef.Context) ImplicitValueInitExpr(T)); 759 } 760 761 /// \brief Build a new \c va_arg expression. 762 /// 763 /// By default, performs semantic analysis to build the new expression. 764 /// Subclasses may override this routine to provide different behavior. 765 OwningExprResult RebuildVAArgExpr(SourceLocation BuiltinLoc, ExprArg SubExpr, 766 QualType T, SourceLocation RParenLoc) { 767 return getSema().ActOnVAArg(BuiltinLoc, move(SubExpr), T.getAsOpaquePtr(), 768 RParenLoc); 769 } 770 771 /// \brief Build a new expression list in parentheses. 772 /// 773 /// By default, performs semantic analysis to build the new expression. 774 /// Subclasses may override this routine to provide different behavior. 775 OwningExprResult RebuildParenListExpr(SourceLocation LParenLoc, 776 MultiExprArg SubExprs, 777 SourceLocation RParenLoc) { 778 return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, move(SubExprs)); 779 } 780 781 /// \brief Build a new address-of-label expression. 782 /// 783 /// By default, performs semantic analysis, using the name of the label 784 /// rather than attempting to map the label statement itself. 785 /// Subclasses may override this routine to provide different behavior. 786 OwningExprResult RebuildAddrLabelExpr(SourceLocation AmpAmpLoc, 787 SourceLocation LabelLoc, 788 LabelStmt *Label) { 789 return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label->getID()); 790 } 791 792 /// \brief Build a new GNU statement expression. 793 /// 794 /// By default, performs semantic analysis to build the new expression. 795 /// Subclasses may override this routine to provide different behavior. 796 OwningExprResult RebuildStmtExpr(SourceLocation LParenLoc, 797 StmtArg SubStmt, 798 SourceLocation RParenLoc) { 799 return getSema().ActOnStmtExpr(LParenLoc, move(SubStmt), RParenLoc); 800 } 801 802 /// \brief Build a new __builtin_types_compatible_p expression. 803 /// 804 /// By default, performs semantic analysis to build the new expression. 805 /// Subclasses may override this routine to provide different behavior. 806 OwningExprResult RebuildTypesCompatibleExpr(SourceLocation BuiltinLoc, 807 QualType T1, QualType T2, 808 SourceLocation RParenLoc) { 809 return getSema().ActOnTypesCompatibleExpr(BuiltinLoc, 810 T1.getAsOpaquePtr(), 811 T2.getAsOpaquePtr(), 812 RParenLoc); 813 } 814 815 /// \brief Build a new __builtin_choose_expr expression. 816 /// 817 /// By default, performs semantic analysis to build the new expression. 818 /// Subclasses may override this routine to provide different behavior. 819 OwningExprResult RebuildChooseExpr(SourceLocation BuiltinLoc, 820 ExprArg Cond, ExprArg LHS, ExprArg RHS, 821 SourceLocation RParenLoc) { 822 return SemaRef.ActOnChooseExpr(BuiltinLoc, 823 move(Cond), move(LHS), move(RHS), 824 RParenLoc); 825 } 826 827 /// \brief Build a new overloaded operator call expression. 828 /// 829 /// By default, performs semantic analysis to build the new expression. 830 /// The semantic analysis provides the behavior of template instantiation, 831 /// copying with transformations that turn what looks like an overloaded 832 /// operator call into a use of a builtin operator, performing 833 /// argument-dependent lookup, etc. Subclasses may override this routine to 834 /// provide different behavior. 835 OwningExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, 836 SourceLocation OpLoc, 837 ExprArg Callee, 838 ExprArg First, 839 ExprArg Second); 840 841 /// \brief Build a new C++ "named" cast expression, such as static_cast or 842 /// reinterpret_cast. 843 /// 844 /// By default, this routine dispatches to one of the more-specific routines 845 /// for a particular named case, e.g., RebuildCXXStaticCastExpr(). 846 /// Subclasses may override this routine to provide different behavior. 847 OwningExprResult RebuildCXXNamedCastExpr(SourceLocation OpLoc, 848 Stmt::StmtClass Class, 849 SourceLocation LAngleLoc, 850 QualType T, 851 SourceLocation RAngleLoc, 852 SourceLocation LParenLoc, 853 ExprArg SubExpr, 854 SourceLocation RParenLoc) { 855 switch (Class) { 856 case Stmt::CXXStaticCastExprClass: 857 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, T, 858 RAngleLoc, LParenLoc, 859 move(SubExpr), RParenLoc); 860 861 case Stmt::CXXDynamicCastExprClass: 862 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, T, 863 RAngleLoc, LParenLoc, 864 move(SubExpr), RParenLoc); 865 866 case Stmt::CXXReinterpretCastExprClass: 867 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, T, 868 RAngleLoc, LParenLoc, 869 move(SubExpr), 870 RParenLoc); 871 872 case Stmt::CXXConstCastExprClass: 873 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, T, 874 RAngleLoc, LParenLoc, 875 move(SubExpr), RParenLoc); 876 877 default: 878 assert(false && "Invalid C++ named cast"); 879 break; 880 } 881 882 return getSema().ExprError(); 883 } 884 885 /// \brief Build a new C++ static_cast expression. 886 /// 887 /// By default, performs semantic analysis to build the new expression. 888 /// Subclasses may override this routine to provide different behavior. 889 OwningExprResult RebuildCXXStaticCastExpr(SourceLocation OpLoc, 890 SourceLocation LAngleLoc, 891 QualType T, 892 SourceLocation RAngleLoc, 893 SourceLocation LParenLoc, 894 ExprArg SubExpr, 895 SourceLocation RParenLoc) { 896 return getSema().ActOnCXXNamedCast(OpLoc, tok::kw_static_cast, 897 LAngleLoc, T.getAsOpaquePtr(), RAngleLoc, 898 LParenLoc, move(SubExpr), RParenLoc); 899 } 900 901 /// \brief Build a new C++ dynamic_cast expression. 902 /// 903 /// By default, performs semantic analysis to build the new expression. 904 /// Subclasses may override this routine to provide different behavior. 905 OwningExprResult RebuildCXXDynamicCastExpr(SourceLocation OpLoc, 906 SourceLocation LAngleLoc, 907 QualType T, 908 SourceLocation RAngleLoc, 909 SourceLocation LParenLoc, 910 ExprArg SubExpr, 911 SourceLocation RParenLoc) { 912 return getSema().ActOnCXXNamedCast(OpLoc, tok::kw_dynamic_cast, 913 LAngleLoc, T.getAsOpaquePtr(), RAngleLoc, 914 LParenLoc, move(SubExpr), RParenLoc); 915 } 916 917 /// \brief Build a new C++ reinterpret_cast expression. 918 /// 919 /// By default, performs semantic analysis to build the new expression. 920 /// Subclasses may override this routine to provide different behavior. 921 OwningExprResult RebuildCXXReinterpretCastExpr(SourceLocation OpLoc, 922 SourceLocation LAngleLoc, 923 QualType T, 924 SourceLocation RAngleLoc, 925 SourceLocation LParenLoc, 926 ExprArg SubExpr, 927 SourceLocation RParenLoc) { 928 return getSema().ActOnCXXNamedCast(OpLoc, tok::kw_reinterpret_cast, 929 LAngleLoc, T.getAsOpaquePtr(), RAngleLoc, 930 LParenLoc, move(SubExpr), RParenLoc); 931 } 932 933 /// \brief Build a new C++ const_cast expression. 934 /// 935 /// By default, performs semantic analysis to build the new expression. 936 /// Subclasses may override this routine to provide different behavior. 937 OwningExprResult RebuildCXXConstCastExpr(SourceLocation OpLoc, 938 SourceLocation LAngleLoc, 939 QualType T, 940 SourceLocation RAngleLoc, 941 SourceLocation LParenLoc, 942 ExprArg SubExpr, 943 SourceLocation RParenLoc) { 944 return getSema().ActOnCXXNamedCast(OpLoc, tok::kw_const_cast, 945 LAngleLoc, T.getAsOpaquePtr(), RAngleLoc, 946 LParenLoc, move(SubExpr), RParenLoc); 947 } 948 949 /// \brief Build a new C++ functional-style cast expression. 950 /// 951 /// By default, performs semantic analysis to build the new expression. 952 /// Subclasses may override this routine to provide different behavior. 953 OwningExprResult RebuildCXXFunctionalCastExpr(SourceRange TypeRange, 954 QualType T, 955 SourceLocation LParenLoc, 956 ExprArg SubExpr, 957 SourceLocation RParenLoc) { 958 Expr *Sub = SubExpr.takeAs<Expr>(); 959 return getSema().ActOnCXXTypeConstructExpr(TypeRange, 960 T.getAsOpaquePtr(), 961 LParenLoc, 962 Sema::MultiExprArg(getSema(), 963 (void **)&Sub, 964 1), 965 /*CommaLocs=*/0, 966 RParenLoc); 967 } 968 969 /// \brief Build a new C++ typeid(type) expression. 970 /// 971 /// By default, performs semantic analysis to build the new expression. 972 /// Subclasses may override this routine to provide different behavior. 973 OwningExprResult RebuildCXXTypeidExpr(SourceLocation TypeidLoc, 974 SourceLocation LParenLoc, 975 QualType T, 976 SourceLocation RParenLoc) { 977 return getSema().ActOnCXXTypeid(TypeidLoc, LParenLoc, true, 978 T.getAsOpaquePtr(), RParenLoc); 979 } 980 981 /// \brief Build a new C++ typeid(expr) expression. 982 /// 983 /// By default, performs semantic analysis to build the new expression. 984 /// Subclasses may override this routine to provide different behavior. 985 OwningExprResult RebuildCXXTypeidExpr(SourceLocation TypeidLoc, 986 SourceLocation LParenLoc, 987 ExprArg Operand, 988 SourceLocation RParenLoc) { 989 OwningExprResult Result 990 = getSema().ActOnCXXTypeid(TypeidLoc, LParenLoc, false, Operand.get(), 991 RParenLoc); 992 if (Result.isInvalid()) 993 return getSema().ExprError(); 994 995 Operand.release(); // FIXME: since ActOnCXXTypeid silently took ownership 996 return move(Result); 997 } 998 999 /// \brief Build a new C++ "this" expression. 1000 /// 1001 /// By default, builds a new "this" expression without performing any 1002 /// semantic analysis. Subclasses may override this routine to provide 1003 /// different behavior. 1004 OwningExprResult RebuildCXXThisExpr(SourceLocation ThisLoc, 1005 QualType ThisType) { 1006 return getSema().Owned( 1007 new (getSema().Context) CXXThisExpr(ThisLoc, ThisType)); 1008 } 1009 1010 /// \brief Build a new C++ throw expression. 1011 /// 1012 /// By default, performs semantic analysis to build the new expression. 1013 /// Subclasses may override this routine to provide different behavior. 1014 OwningExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, ExprArg Sub) { 1015 return getSema().ActOnCXXThrow(ThrowLoc, move(Sub)); 1016 } 1017 1018 /// \brief Build a new C++ default-argument expression. 1019 /// 1020 /// By default, builds a new default-argument expression, which does not 1021 /// require any semantic analysis. Subclasses may override this routine to 1022 /// provide different behavior. 1023 OwningExprResult RebuildCXXDefaultArgExpr(ParmVarDecl *Param) { 1024 return getSema().Owned(CXXDefaultArgExpr::Create(getSema().Context, Param)); 1025 } 1026 1027 /// \brief Build a new C++ zero-initialization expression. 1028 /// 1029 /// By default, performs semantic analysis to build the new expression. 1030 /// Subclasses may override this routine to provide different behavior. 1031 OwningExprResult RebuildCXXZeroInitValueExpr(SourceLocation TypeStartLoc, 1032 SourceLocation LParenLoc, 1033 QualType T, 1034 SourceLocation RParenLoc) { 1035 return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeStartLoc), 1036 T.getAsOpaquePtr(), LParenLoc, 1037 MultiExprArg(getSema(), 0, 0), 1038 0, RParenLoc); 1039 } 1040 1041 /// \brief Build a new C++ conditional declaration expression. 1042 /// 1043 /// By default, performs semantic analysis to build the new expression. 1044 /// Subclasses may override this routine to provide different behavior. 1045 OwningExprResult RebuildCXXConditionDeclExpr(SourceLocation StartLoc, 1046 SourceLocation EqLoc, 1047 VarDecl *Var) { 1048 return SemaRef.Owned(new (SemaRef.Context) CXXConditionDeclExpr(StartLoc, 1049 EqLoc, 1050 Var)); 1051 } 1052 1053 /// \brief Build a new C++ "new" expression. 1054 /// 1055 /// By default, performs semantic analysis to build the new expression. 1056 /// Subclasses may override this routine to provide different behavior. 1057 OwningExprResult RebuildCXXNewExpr(SourceLocation StartLoc, 1058 bool UseGlobal, 1059 SourceLocation PlacementLParen, 1060 MultiExprArg PlacementArgs, 1061 SourceLocation PlacementRParen, 1062 bool ParenTypeId, 1063 QualType AllocType, 1064 SourceLocation TypeLoc, 1065 SourceRange TypeRange, 1066 ExprArg ArraySize, 1067 SourceLocation ConstructorLParen, 1068 MultiExprArg ConstructorArgs, 1069 SourceLocation ConstructorRParen) { 1070 return getSema().BuildCXXNew(StartLoc, UseGlobal, 1071 PlacementLParen, 1072 move(PlacementArgs), 1073 PlacementRParen, 1074 ParenTypeId, 1075 AllocType, 1076 TypeLoc, 1077 TypeRange, 1078 move(ArraySize), 1079 ConstructorLParen, 1080 move(ConstructorArgs), 1081 ConstructorRParen); 1082 } 1083 1084 /// \brief Build a new C++ "delete" expression. 1085 /// 1086 /// By default, performs semantic analysis to build the new expression. 1087 /// Subclasses may override this routine to provide different behavior. 1088 OwningExprResult RebuildCXXDeleteExpr(SourceLocation StartLoc, 1089 bool IsGlobalDelete, 1090 bool IsArrayForm, 1091 ExprArg Operand) { 1092 return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm, 1093 move(Operand)); 1094 } 1095 1096 /// \brief Build a new unary type trait expression. 1097 /// 1098 /// By default, performs semantic analysis to build the new expression. 1099 /// Subclasses may override this routine to provide different behavior. 1100 OwningExprResult RebuildUnaryTypeTrait(UnaryTypeTrait Trait, 1101 SourceLocation StartLoc, 1102 SourceLocation LParenLoc, 1103 QualType T, 1104 SourceLocation RParenLoc) { 1105 return getSema().ActOnUnaryTypeTrait(Trait, StartLoc, LParenLoc, 1106 T.getAsOpaquePtr(), RParenLoc); 1107 } 1108 1109 /// \brief Build a new qualified declaration reference expression. 1110 /// 1111 /// By default, performs semantic analysis to build the new expression. 1112 /// Subclasses may override this routine to provide different behavior. 1113 OwningExprResult RebuildQualifiedDeclRefExpr(NestedNameSpecifier *NNS, 1114 SourceRange QualifierRange, 1115 NamedDecl *ND, 1116 SourceLocation Location, 1117 bool IsAddressOfOperand) { 1118 CXXScopeSpec SS; 1119 SS.setRange(QualifierRange); 1120 SS.setScopeRep(NNS); 1121 return getSema().ActOnDeclarationNameExpr(/*Scope=*/0, 1122 Location, 1123 ND->getDeclName(), 1124 /*Trailing lparen=*/false, 1125 &SS, 1126 IsAddressOfOperand); 1127 } 1128 1129 /// \brief Build a new (previously unresolved) declaration reference 1130 /// expression. 1131 /// 1132 /// By default, performs semantic analysis to build the new expression. 1133 /// Subclasses may override this routine to provide different behavior. 1134 OwningExprResult RebuildUnresolvedDeclRefExpr(NestedNameSpecifier *NNS, 1135 SourceRange QualifierRange, 1136 DeclarationName Name, 1137 SourceLocation Location, 1138 bool IsAddressOfOperand) { 1139 CXXScopeSpec SS; 1140 SS.setRange(QualifierRange); 1141 SS.setScopeRep(NNS); 1142 return getSema().ActOnDeclarationNameExpr(/*Scope=*/0, 1143 Location, 1144 Name, 1145 /*Trailing lparen=*/false, 1146 &SS, 1147 IsAddressOfOperand); 1148 } 1149 1150 /// \brief Build a new template-id expression. 1151 /// 1152 /// By default, performs semantic analysis to build the new expression. 1153 /// Subclasses may override this routine to provide different behavior. 1154 OwningExprResult RebuildTemplateIdExpr(TemplateName Template, 1155 SourceLocation TemplateLoc, 1156 SourceLocation LAngleLoc, 1157 TemplateArgument *TemplateArgs, 1158 unsigned NumTemplateArgs, 1159 SourceLocation RAngleLoc) { 1160 return getSema().BuildTemplateIdExpr(Template, TemplateLoc, 1161 LAngleLoc, 1162 TemplateArgs, NumTemplateArgs, 1163 RAngleLoc); 1164 } 1165 1166 /// \brief Build a new object-construction expression. 1167 /// 1168 /// By default, performs semantic analysis to build the new expression. 1169 /// Subclasses may override this routine to provide different behavior. 1170 OwningExprResult RebuildCXXConstructExpr(QualType T, 1171 CXXConstructorDecl *Constructor, 1172 bool IsElidable, 1173 MultiExprArg Args) { 1174 unsigned NumArgs = Args.size(); 1175 Expr **ArgsExprs = (Expr **)Args.release(); 1176 return getSema().Owned(SemaRef.BuildCXXConstructExpr(T, Constructor, 1177 IsElidable, 1178 ArgsExprs, 1179 NumArgs)); 1180 } 1181 1182 /// \brief Build a new object-construction expression. 1183 /// 1184 /// By default, performs semantic analysis to build the new expression. 1185 /// Subclasses may override this routine to provide different behavior. 1186 OwningExprResult RebuildCXXTemporaryObjectExpr(SourceLocation TypeBeginLoc, 1187 QualType T, 1188 SourceLocation LParenLoc, 1189 MultiExprArg Args, 1190 SourceLocation *Commas, 1191 SourceLocation RParenLoc) { 1192 return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeBeginLoc), 1193 T.getAsOpaquePtr(), 1194 LParenLoc, 1195 move(Args), 1196 Commas, 1197 RParenLoc); 1198 } 1199 1200 /// \brief Build a new object-construction expression. 1201 /// 1202 /// By default, performs semantic analysis to build the new expression. 1203 /// Subclasses may override this routine to provide different behavior. 1204 OwningExprResult RebuildCXXUnresolvedConstructExpr(SourceLocation TypeBeginLoc, 1205 QualType T, 1206 SourceLocation LParenLoc, 1207 MultiExprArg Args, 1208 SourceLocation *Commas, 1209 SourceLocation RParenLoc) { 1210 return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeBeginLoc, 1211 /*FIXME*/LParenLoc), 1212 T.getAsOpaquePtr(), 1213 LParenLoc, 1214 move(Args), 1215 Commas, 1216 RParenLoc); 1217 } 1218 1219 /// \brief Build a new member reference expression. 1220 /// 1221 /// By default, performs semantic analysis to build the new expression. 1222 /// Subclasses may override this routine to provide different behavior. 1223 OwningExprResult RebuildCXXUnresolvedMemberExpr(ExprArg BaseE, 1224 bool IsArrow, 1225 SourceLocation OperatorLoc, 1226 DeclarationName Name, 1227 SourceLocation MemberLoc) { 1228 OwningExprResult Base = move(BaseE); 1229 tok::TokenKind OpKind = IsArrow? tok::arrow : tok::period; 1230 CXXScopeSpec SS; 1231 Base = SemaRef.ActOnCXXEnterMemberScope(0, SS, move(Base), OpKind); 1232 if (Base.isInvalid()) 1233 return SemaRef.ExprError(); 1234 1235 assert(Name.getAsIdentifierInfo() && 1236 "Cannot transform member references with non-identifier members"); 1237 Base = SemaRef.ActOnMemberReferenceExpr(/*Scope=*/0, 1238 move(Base), OperatorLoc, OpKind, 1239 MemberLoc, 1240 *Name.getAsIdentifierInfo(), 1241 /*FIXME?*/Sema::DeclPtrTy::make((Decl*)0)); 1242 SemaRef.ActOnCXXExitMemberScope(0, SS); 1243 return move(Base); 1244 } 1245 1246 /// \brief Build a new Objective-C @encode expression. 1247 /// 1248 /// By default, performs semantic analysis to build the new expression. 1249 /// Subclasses may override this routine to provide different behavior. 1250 OwningExprResult RebuildObjCEncodeExpr(SourceLocation AtLoc, 1251 QualType T, 1252 SourceLocation RParenLoc) { 1253 return SemaRef.Owned(SemaRef.BuildObjCEncodeExpression(AtLoc, T, 1254 RParenLoc)); 1255 } 1256 1257 /// \brief Build a new Objective-C protocol expression. 1258 /// 1259 /// By default, performs semantic analysis to build the new expression. 1260 /// Subclasses may override this routine to provide different behavior. 1261 OwningExprResult RebuildObjCProtocolExpr(ObjCProtocolDecl *Protocol, 1262 SourceLocation AtLoc, 1263 SourceLocation ProtoLoc, 1264 SourceLocation LParenLoc, 1265 SourceLocation RParenLoc) { 1266 return SemaRef.Owned(SemaRef.ParseObjCProtocolExpression( 1267 Protocol->getIdentifier(), 1268 AtLoc, 1269 ProtoLoc, 1270 LParenLoc, 1271 RParenLoc)); 1272 } 1273 1274 /// \brief Build a new shuffle vector expression. 1275 /// 1276 /// By default, performs semantic analysis to build the new expression. 1277 /// Subclasses may override this routine to provide different behavior. 1278 OwningExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc, 1279 MultiExprArg SubExprs, 1280 SourceLocation RParenLoc) { 1281 // Find the declaration for __builtin_shufflevector 1282 const IdentifierInfo &Name 1283 = SemaRef.Context.Idents.get("__builtin_shufflevector"); 1284 TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl(); 1285 DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name)); 1286 assert(Lookup.first != Lookup.second && "No __builtin_shufflevector?"); 1287 1288 // Build a reference to the __builtin_shufflevector builtin 1289 FunctionDecl *Builtin = cast<FunctionDecl>(*Lookup.first); 1290 Expr *Callee 1291 = new (SemaRef.Context) DeclRefExpr(Builtin, Builtin->getType(), 1292 BuiltinLoc, false, false); 1293 SemaRef.UsualUnaryConversions(Callee); 1294 1295 // Build the CallExpr 1296 unsigned NumSubExprs = SubExprs.size(); 1297 Expr **Subs = (Expr **)SubExprs.release(); 1298 CallExpr *TheCall = new (SemaRef.Context) CallExpr(SemaRef.Context, Callee, 1299 Subs, NumSubExprs, 1300 Builtin->getResultType(), 1301 RParenLoc); 1302 OwningExprResult OwnedCall(SemaRef.Owned(TheCall)); 1303 1304 // Type-check the __builtin_shufflevector expression. 1305 OwningExprResult Result = SemaRef.SemaBuiltinShuffleVector(TheCall); 1306 if (Result.isInvalid()) 1307 return SemaRef.ExprError(); 1308 1309 OwnedCall.release(); 1310 return move(Result); 1311 } 1312}; 1313 1314 1315template<typename Derived> 1316Sema::OwningExprResult TreeTransform<Derived>::TransformExpr(Expr *E, 1317 bool isAddressOfOperand) { 1318 if (!E) 1319 return SemaRef.Owned(E); 1320 1321 switch (E->getStmtClass()) { 1322 case Stmt::NoStmtClass: break; 1323#define STMT(Node, Parent) case Stmt::Node##Class: break; 1324#define EXPR(Node, Parent) \ 1325 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E)); 1326#include "clang/AST/StmtNodes.def" 1327 } 1328 1329 return SemaRef.Owned(E->Retain()); 1330} 1331 1332template<typename Derived> 1333NestedNameSpecifier * 1334TreeTransform<Derived>::TransformNestedNameSpecifier(NestedNameSpecifier *NNS, 1335 SourceRange Range) { 1336 // Instantiate the prefix of this nested name specifier. 1337 NestedNameSpecifier *Prefix = NNS->getPrefix(); 1338 if (Prefix) { 1339 Prefix = getDerived().TransformNestedNameSpecifier(Prefix, Range); 1340 if (!Prefix) 1341 return 0; 1342 } 1343 1344 switch (NNS->getKind()) { 1345 case NestedNameSpecifier::Identifier: 1346 assert(Prefix && 1347 "Can't have an identifier nested-name-specifier with no prefix"); 1348 if (!getDerived().AlwaysRebuild() && Prefix == NNS->getPrefix()) 1349 return NNS; 1350 1351 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, 1352 *NNS->getAsIdentifier()); 1353 1354 case NestedNameSpecifier::Namespace: { 1355 NamespaceDecl *NS 1356 = cast_or_null<NamespaceDecl>( 1357 getDerived().TransformDecl(NNS->getAsNamespace())); 1358 if (!getDerived().AlwaysRebuild() && 1359 Prefix == NNS->getPrefix() && 1360 NS == NNS->getAsNamespace()) 1361 return NNS; 1362 1363 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, NS); 1364 } 1365 1366 case NestedNameSpecifier::Global: 1367 // There is no meaningful transformation that one could perform on the 1368 // global scope. 1369 return NNS; 1370 1371 case NestedNameSpecifier::TypeSpecWithTemplate: 1372 case NestedNameSpecifier::TypeSpec: { 1373 QualType T = getDerived().TransformType(QualType(NNS->getAsType(), 0)); 1374 if (T.isNull()) 1375 return 0; 1376 1377 if (!getDerived().AlwaysRebuild() && 1378 Prefix == NNS->getPrefix() && 1379 T == QualType(NNS->getAsType(), 0)) 1380 return NNS; 1381 1382 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, 1383 NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate, 1384 T); 1385 } 1386 } 1387 1388 // Required to silence a GCC warning 1389 return 0; 1390} 1391 1392template<typename Derived> 1393TemplateName 1394TreeTransform<Derived>::TransformTemplateName(TemplateName Name) { 1395 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) { 1396 NestedNameSpecifier *NNS 1397 = getDerived().TransformNestedNameSpecifier(QTN->getQualifier(), 1398 /*FIXME:*/SourceRange(getDerived().getBaseLocation())); 1399 if (!NNS) 1400 return TemplateName(); 1401 1402 if (TemplateDecl *Template = QTN->getTemplateDecl()) { 1403 TemplateDecl *TransTemplate 1404 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Template)); 1405 if (!TransTemplate) 1406 return TemplateName(); 1407 1408 if (!getDerived().AlwaysRebuild() && 1409 NNS == QTN->getQualifier() && 1410 TransTemplate == Template) 1411 return Name; 1412 1413 return getDerived().RebuildTemplateName(NNS, QTN->hasTemplateKeyword(), 1414 TransTemplate); 1415 } 1416 1417 OverloadedFunctionDecl *Ovl = QTN->getOverloadedFunctionDecl(); 1418 assert(Ovl && "Not a template name or an overload set?"); 1419 OverloadedFunctionDecl *TransOvl 1420 = cast_or_null<OverloadedFunctionDecl>(getDerived().TransformDecl(Ovl)); 1421 if (!TransOvl) 1422 return TemplateName(); 1423 1424 if (!getDerived().AlwaysRebuild() && 1425 NNS == QTN->getQualifier() && 1426 TransOvl == Ovl) 1427 return Name; 1428 1429 return getDerived().RebuildTemplateName(NNS, QTN->hasTemplateKeyword(), 1430 TransOvl); 1431 } 1432 1433 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) { 1434 NestedNameSpecifier *NNS 1435 = getDerived().TransformNestedNameSpecifier(DTN->getQualifier(), 1436 /*FIXME:*/SourceRange(getDerived().getBaseLocation())); 1437 if (!NNS) 1438 return TemplateName(); 1439 1440 if (!getDerived().AlwaysRebuild() && 1441 NNS == DTN->getQualifier()) 1442 return Name; 1443 1444 return getDerived().RebuildTemplateName(NNS, *DTN->getName()); 1445 } 1446 1447 if (TemplateDecl *Template = Name.getAsTemplateDecl()) { 1448 TemplateDecl *TransTemplate 1449 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Template)); 1450 if (!TransTemplate) 1451 return TemplateName(); 1452 1453 if (!getDerived().AlwaysRebuild() && 1454 TransTemplate == Template) 1455 return Name; 1456 1457 return TemplateName(TransTemplate); 1458 } 1459 1460 OverloadedFunctionDecl *Ovl = Name.getAsOverloadedFunctionDecl(); 1461 assert(Ovl && "Not a template name or an overload set?"); 1462 OverloadedFunctionDecl *TransOvl 1463 = cast_or_null<OverloadedFunctionDecl>(getDerived().TransformDecl(Ovl)); 1464 if (!TransOvl) 1465 return TemplateName(); 1466 1467 if (!getDerived().AlwaysRebuild() && 1468 TransOvl == Ovl) 1469 return Name; 1470 1471 return TemplateName(TransOvl); 1472} 1473 1474template<typename Derived> 1475TemplateArgument 1476TreeTransform<Derived>::TransformTemplateArgument(const TemplateArgument &Arg) { 1477 switch (Arg.getKind()) { 1478 case TemplateArgument::Null: 1479 case TemplateArgument::Integral: 1480 return Arg; 1481 1482 case TemplateArgument::Type: { 1483 QualType T = getDerived().TransformType(Arg.getAsType()); 1484 if (T.isNull()) 1485 return TemplateArgument(); 1486 return TemplateArgument(Arg.getLocation(), T); 1487 } 1488 1489 case TemplateArgument::Declaration: { 1490 Decl *D = getDerived().TransformDecl(Arg.getAsDecl()); 1491 if (!D) 1492 return TemplateArgument(); 1493 return TemplateArgument(Arg.getLocation(), D); 1494 } 1495 1496 case TemplateArgument::Expression: { 1497 // Template argument expressions are not potentially evaluated. 1498 EnterExpressionEvaluationContext Unevaluated(getSema(), 1499 Action::Unevaluated); 1500 1501 Sema::OwningExprResult E = getDerived().TransformExpr(Arg.getAsExpr()); 1502 if (E.isInvalid()) 1503 return TemplateArgument(); 1504 return TemplateArgument(E.takeAs<Expr>()); 1505 } 1506 1507 case TemplateArgument::Pack: { 1508 llvm::SmallVector<TemplateArgument, 4> TransformedArgs; 1509 TransformedArgs.reserve(Arg.pack_size()); 1510 for (TemplateArgument::pack_iterator A = Arg.pack_begin(), 1511 AEnd = Arg.pack_end(); 1512 A != AEnd; ++A) { 1513 TemplateArgument TA = getDerived().TransformTemplateArgument(*A); 1514 if (TA.isNull()) 1515 return TA; 1516 1517 TransformedArgs.push_back(TA); 1518 } 1519 TemplateArgument Result; 1520 Result.setArgumentPack(TransformedArgs.data(), TransformedArgs.size(), 1521 true); 1522 return Result; 1523 } 1524 } 1525 1526 // Work around bogus GCC warning 1527 return TemplateArgument(); 1528} 1529 1530//===----------------------------------------------------------------------===// 1531// Type transformation 1532//===----------------------------------------------------------------------===// 1533 1534template<typename Derived> 1535QualType TreeTransform<Derived>::TransformType(QualType T) { 1536 if (getDerived().AlreadyTransformed(T)) 1537 return T; 1538 1539 QualType Result; 1540 switch (T->getTypeClass()) { 1541#define ABSTRACT_TYPE(CLASS, PARENT) 1542#define TYPE(CLASS, PARENT) \ 1543 case Type::CLASS: \ 1544 Result = getDerived().Transform##CLASS##Type( \ 1545 static_cast<CLASS##Type*>(T.getTypePtr())); \ 1546 break; 1547#include "clang/AST/TypeNodes.def" 1548 } 1549 1550 if (Result.isNull() || T == Result) 1551 return Result; 1552 1553 return getDerived().AddTypeQualifiers(Result, T.getCVRQualifiers()); 1554} 1555 1556template<typename Derived> 1557QualType 1558TreeTransform<Derived>::AddTypeQualifiers(QualType T, unsigned CVRQualifiers) { 1559 if (CVRQualifiers && !T->isFunctionType() && !T->isReferenceType()) 1560 return T.getWithAdditionalQualifiers(CVRQualifiers); 1561 1562 return T; 1563} 1564 1565template<typename Derived> 1566QualType TreeTransform<Derived>::TransformExtQualType(const ExtQualType *T) { 1567 // FIXME: Implement 1568 return QualType(T, 0); 1569} 1570 1571template<typename Derived> 1572QualType TreeTransform<Derived>::TransformBuiltinType(const BuiltinType *T) { 1573 // Nothing to do 1574 return QualType(T, 0); 1575} 1576 1577template<typename Derived> 1578QualType TreeTransform<Derived>::TransformFixedWidthIntType( 1579 const FixedWidthIntType *T) { 1580 // FIXME: Implement 1581 return QualType(T, 0); 1582} 1583 1584template<typename Derived> 1585QualType TreeTransform<Derived>::TransformComplexType(const ComplexType *T) { 1586 // FIXME: Implement 1587 return QualType(T, 0); 1588} 1589 1590template<typename Derived> 1591QualType TreeTransform<Derived>::TransformPointerType(const PointerType *T) { 1592 QualType PointeeType = getDerived().TransformType(T->getPointeeType()); 1593 if (PointeeType.isNull()) 1594 return QualType(); 1595 1596 if (!getDerived().AlwaysRebuild() && 1597 PointeeType == T->getPointeeType()) 1598 return QualType(T, 0); 1599 1600 return getDerived().RebuildPointerType(PointeeType); 1601} 1602 1603template<typename Derived> 1604QualType 1605TreeTransform<Derived>::TransformBlockPointerType(const BlockPointerType *T) { 1606 QualType PointeeType = getDerived().TransformType(T->getPointeeType()); 1607 if (PointeeType.isNull()) 1608 return QualType(); 1609 1610 if (!getDerived().AlwaysRebuild() && 1611 PointeeType == T->getPointeeType()) 1612 return QualType(T, 0); 1613 1614 return getDerived().RebuildBlockPointerType(PointeeType); 1615} 1616 1617template<typename Derived> 1618QualType 1619TreeTransform<Derived>::TransformLValueReferenceType( 1620 const LValueReferenceType *T) { 1621 QualType PointeeType = getDerived().TransformType(T->getPointeeType()); 1622 if (PointeeType.isNull()) 1623 return QualType(); 1624 1625 if (!getDerived().AlwaysRebuild() && 1626 PointeeType == T->getPointeeType()) 1627 return QualType(T, 0); 1628 1629 return getDerived().RebuildLValueReferenceType(PointeeType); 1630} 1631 1632template<typename Derived> 1633QualType 1634TreeTransform<Derived>::TransformRValueReferenceType( 1635 const RValueReferenceType *T) { 1636 QualType PointeeType = getDerived().TransformType(T->getPointeeType()); 1637 if (PointeeType.isNull()) 1638 return QualType(); 1639 1640 if (!getDerived().AlwaysRebuild() && 1641 PointeeType == T->getPointeeType()) 1642 return QualType(T, 0); 1643 1644 return getDerived().RebuildRValueReferenceType(PointeeType); 1645} 1646 1647template<typename Derived> 1648QualType 1649TreeTransform<Derived>::TransformMemberPointerType(const MemberPointerType *T) { 1650 QualType PointeeType = getDerived().TransformType(T->getPointeeType()); 1651 if (PointeeType.isNull()) 1652 return QualType(); 1653 1654 QualType ClassType = getDerived().TransformType(QualType(T->getClass(), 0)); 1655 if (ClassType.isNull()) 1656 return QualType(); 1657 1658 if (!getDerived().AlwaysRebuild() && 1659 PointeeType == T->getPointeeType() && 1660 ClassType == QualType(T->getClass(), 0)) 1661 return QualType(T, 0); 1662 1663 return getDerived().RebuildMemberPointerType(PointeeType, ClassType); 1664} 1665 1666template<typename Derived> 1667QualType 1668TreeTransform<Derived>::TransformConstantArrayType(const ConstantArrayType *T) { 1669 QualType ElementType = getDerived().TransformType(T->getElementType()); 1670 if (ElementType.isNull()) 1671 return QualType(); 1672 1673 if (!getDerived().AlwaysRebuild() && 1674 ElementType == T->getElementType()) 1675 return QualType(T, 0); 1676 1677 return getDerived().RebuildConstantArrayType(ElementType, 1678 T->getSizeModifier(), 1679 T->getSize(), 1680 T->getIndexTypeQualifier()); 1681} 1682 1683template<typename Derived> 1684QualType 1685TreeTransform<Derived>::TransformConstantArrayWithExprType( 1686 const ConstantArrayWithExprType *T) { 1687 QualType ElementType = getDerived().TransformType(T->getElementType()); 1688 if (ElementType.isNull()) 1689 return QualType(); 1690 1691 // Array bounds are not potentially evaluated contexts 1692 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 1693 1694 Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); 1695 if (Size.isInvalid()) 1696 return QualType(); 1697 1698 if (!getDerived().AlwaysRebuild() && 1699 ElementType == T->getElementType() && 1700 Size.get() == T->getSizeExpr()) 1701 return QualType(T, 0); 1702 1703 return getDerived().RebuildConstantArrayWithExprType(ElementType, 1704 T->getSizeModifier(), 1705 T->getSize(), 1706 Size.takeAs<Expr>(), 1707 T->getIndexTypeQualifier(), 1708 T->getBracketsRange()); 1709} 1710 1711template<typename Derived> 1712QualType 1713TreeTransform<Derived>::TransformConstantArrayWithoutExprType( 1714 const ConstantArrayWithoutExprType *T) { 1715 QualType ElementType = getDerived().TransformType(T->getElementType()); 1716 if (ElementType.isNull()) 1717 return QualType(); 1718 1719 if (!getDerived().AlwaysRebuild() && 1720 ElementType == T->getElementType()) 1721 return QualType(T, 0); 1722 1723 return getDerived().RebuildConstantArrayWithoutExprType(ElementType, 1724 T->getSizeModifier(), 1725 T->getSize(), 1726 T->getIndexTypeQualifier()); 1727} 1728 1729template<typename Derived> 1730QualType TreeTransform<Derived>::TransformIncompleteArrayType( 1731 const IncompleteArrayType *T) { 1732 QualType ElementType = getDerived().TransformType(T->getElementType()); 1733 if (ElementType.isNull()) 1734 return QualType(); 1735 1736 if (!getDerived().AlwaysRebuild() && 1737 ElementType == T->getElementType()) 1738 return QualType(T, 0); 1739 1740 return getDerived().RebuildIncompleteArrayType(ElementType, 1741 T->getSizeModifier(), 1742 T->getIndexTypeQualifier()); 1743} 1744 1745template<typename Derived> 1746QualType TreeTransform<Derived>::TransformVariableArrayType( 1747 const VariableArrayType *T) { 1748 QualType ElementType = getDerived().TransformType(T->getElementType()); 1749 if (ElementType.isNull()) 1750 return QualType(); 1751 1752 // Array bounds are not potentially evaluated contexts 1753 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 1754 1755 Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); 1756 if (Size.isInvalid()) 1757 return QualType(); 1758 1759 if (!getDerived().AlwaysRebuild() && 1760 ElementType == T->getElementType() && 1761 Size.get() == T->getSizeExpr()) { 1762 Size.take(); 1763 return QualType(T, 0); 1764 } 1765 1766 return getDerived().RebuildVariableArrayType(ElementType, 1767 T->getSizeModifier(), 1768 move(Size), 1769 T->getIndexTypeQualifier(), 1770 T->getBracketsRange()); 1771} 1772 1773template<typename Derived> 1774QualType TreeTransform<Derived>::TransformDependentSizedArrayType( 1775 const DependentSizedArrayType *T) { 1776 QualType ElementType = getDerived().TransformType(T->getElementType()); 1777 if (ElementType.isNull()) 1778 return QualType(); 1779 1780 // Array bounds are not potentially evaluated contexts 1781 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 1782 1783 Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); 1784 if (Size.isInvalid()) 1785 return QualType(); 1786 1787 if (!getDerived().AlwaysRebuild() && 1788 ElementType == T->getElementType() && 1789 Size.get() == T->getSizeExpr()) { 1790 Size.take(); 1791 return QualType(T, 0); 1792 } 1793 1794 return getDerived().RebuildDependentSizedArrayType(ElementType, 1795 T->getSizeModifier(), 1796 move(Size), 1797 T->getIndexTypeQualifier(), 1798 T->getBracketsRange()); 1799} 1800 1801template<typename Derived> 1802QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType( 1803 const DependentSizedExtVectorType *T) { 1804 QualType ElementType = getDerived().TransformType(T->getElementType()); 1805 if (ElementType.isNull()) 1806 return QualType(); 1807 1808 // Vector sizes are not potentially evaluated contexts 1809 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 1810 1811 Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); 1812 if (Size.isInvalid()) 1813 return QualType(); 1814 1815 if (!getDerived().AlwaysRebuild() && 1816 ElementType == T->getElementType() && 1817 Size.get() == T->getSizeExpr()) { 1818 Size.take(); 1819 return QualType(T, 0); 1820 } 1821 1822 return getDerived().RebuildDependentSizedExtVectorType(ElementType, 1823 move(Size), 1824 T->getAttributeLoc()); 1825} 1826 1827template<typename Derived> 1828QualType TreeTransform<Derived>::TransformVectorType(const VectorType *T) { 1829 QualType ElementType = getDerived().TransformType(T->getElementType()); 1830 if (ElementType.isNull()) 1831 return QualType(); 1832 1833 if (!getDerived().AlwaysRebuild() && 1834 ElementType == T->getElementType()) 1835 return QualType(T, 0); 1836 1837 return getDerived().RebuildVectorType(ElementType, T->getNumElements()); 1838} 1839 1840template<typename Derived> 1841QualType 1842TreeTransform<Derived>::TransformExtVectorType(const ExtVectorType *T) { 1843 QualType ElementType = getDerived().TransformType(T->getElementType()); 1844 if (ElementType.isNull()) 1845 return QualType(); 1846 1847 if (!getDerived().AlwaysRebuild() && 1848 ElementType == T->getElementType()) 1849 return QualType(T, 0); 1850 1851 return getDerived().RebuildExtVectorType(ElementType, T->getNumElements(), 1852 /*FIXME*/SourceLocation()); 1853} 1854 1855template<typename Derived> 1856QualType TreeTransform<Derived>::TransformFunctionProtoType( 1857 const FunctionProtoType *T) { 1858 QualType ResultType = getDerived().TransformType(T->getResultType()); 1859 if (ResultType.isNull()) 1860 return QualType(); 1861 1862 llvm::SmallVector<QualType, 4> ParamTypes; 1863 for (FunctionProtoType::arg_type_iterator Param = T->arg_type_begin(), 1864 ParamEnd = T->arg_type_end(); 1865 Param != ParamEnd; ++Param) { 1866 QualType P = getDerived().TransformType(*Param); 1867 if (P.isNull()) 1868 return QualType(); 1869 1870 ParamTypes.push_back(P); 1871 } 1872 1873 if (!getDerived().AlwaysRebuild() && 1874 ResultType == T->getResultType() && 1875 std::equal(T->arg_type_begin(), T->arg_type_end(), ParamTypes.begin())) 1876 return QualType(T, 0); 1877 1878 return getDerived().RebuildFunctionProtoType(ResultType, ParamTypes.data(), 1879 ParamTypes.size(), T->isVariadic(), 1880 T->getTypeQuals()); 1881} 1882 1883template<typename Derived> 1884QualType TreeTransform<Derived>::TransformFunctionNoProtoType( 1885 const FunctionNoProtoType *T) { 1886 // FIXME: Implement 1887 return QualType(T, 0); 1888} 1889 1890template<typename Derived> 1891QualType TreeTransform<Derived>::TransformTypedefType(const TypedefType *T) { 1892 TypedefDecl *Typedef 1893 = cast_or_null<TypedefDecl>(getDerived().TransformDecl(T->getDecl())); 1894 if (!Typedef) 1895 return QualType(); 1896 1897 if (!getDerived().AlwaysRebuild() && 1898 Typedef == T->getDecl()) 1899 return QualType(T, 0); 1900 1901 return getDerived().RebuildTypedefType(Typedef); 1902} 1903 1904template<typename Derived> 1905QualType TreeTransform<Derived>::TransformTypeOfExprType( 1906 const TypeOfExprType *T) { 1907 // typeof expressions are not potentially evaluated contexts 1908 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 1909 1910 Sema::OwningExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); 1911 if (E.isInvalid()) 1912 return QualType(); 1913 1914 if (!getDerived().AlwaysRebuild() && 1915 E.get() == T->getUnderlyingExpr()) { 1916 E.take(); 1917 return QualType(T, 0); 1918 } 1919 1920 return getDerived().RebuildTypeOfExprType(move(E)); 1921} 1922 1923template<typename Derived> 1924QualType TreeTransform<Derived>::TransformTypeOfType(const TypeOfType *T) { 1925 QualType Underlying = getDerived().TransformType(T->getUnderlyingType()); 1926 if (Underlying.isNull()) 1927 return QualType(); 1928 1929 if (!getDerived().AlwaysRebuild() && 1930 Underlying == T->getUnderlyingType()) 1931 return QualType(T, 0); 1932 1933 return getDerived().RebuildTypeOfType(Underlying); 1934} 1935 1936template<typename Derived> 1937QualType TreeTransform<Derived>::TransformDecltypeType(const DecltypeType *T) { 1938 // decltype expressions are not potentially evaluated contexts 1939 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 1940 1941 Sema::OwningExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); 1942 if (E.isInvalid()) 1943 return QualType(); 1944 1945 if (!getDerived().AlwaysRebuild() && 1946 E.get() == T->getUnderlyingExpr()) { 1947 E.take(); 1948 return QualType(T, 0); 1949 } 1950 1951 return getDerived().RebuildDecltypeType(move(E)); 1952} 1953 1954template<typename Derived> 1955QualType TreeTransform<Derived>::TransformRecordType(const RecordType *T) { 1956 RecordDecl *Record 1957 = cast_or_null<RecordDecl>(getDerived().TransformDecl(T->getDecl())); 1958 if (!Record) 1959 return QualType(); 1960 1961 if (!getDerived().AlwaysRebuild() && 1962 Record == T->getDecl()) 1963 return QualType(T, 0); 1964 1965 return getDerived().RebuildRecordType(Record); 1966} 1967 1968template<typename Derived> 1969QualType TreeTransform<Derived>::TransformEnumType(const EnumType *T) { 1970 EnumDecl *Enum 1971 = cast_or_null<EnumDecl>(getDerived().TransformDecl(T->getDecl())); 1972 if (!Enum) 1973 return QualType(); 1974 1975 if (!getDerived().AlwaysRebuild() && 1976 Enum == T->getDecl()) 1977 return QualType(T, 0); 1978 1979 return getDerived().RebuildEnumType(Enum); 1980} 1981 1982template<typename Derived> 1983QualType TreeTransform<Derived>::TransformTemplateTypeParmType( 1984 const TemplateTypeParmType *T) { 1985 // Nothing to do 1986 return QualType(T, 0); 1987} 1988 1989template<typename Derived> 1990QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 1991 const TemplateSpecializationType *T) { 1992 TemplateName Template 1993 = getDerived().TransformTemplateName(T->getTemplateName()); 1994 if (Template.isNull()) 1995 return QualType(); 1996 1997 llvm::SmallVector<TemplateArgument, 4> NewTemplateArgs; 1998 NewTemplateArgs.reserve(T->getNumArgs()); 1999 for (TemplateSpecializationType::iterator Arg = T->begin(), ArgEnd = T->end(); 2000 Arg != ArgEnd; ++Arg) { 2001 TemplateArgument NewArg = getDerived().TransformTemplateArgument(*Arg); 2002 if (NewArg.isNull()) 2003 return QualType(); 2004 2005 NewTemplateArgs.push_back(NewArg); 2006 } 2007 2008 // FIXME: early abort if all of the template arguments and such are the 2009 // same. 2010 2011 // FIXME: We're missing the locations of the template name, '<', and '>'. 2012 return getDerived().RebuildTemplateSpecializationType(Template, 2013 NewTemplateArgs.data(), 2014 NewTemplateArgs.size()); 2015} 2016 2017template<typename Derived> 2018QualType TreeTransform<Derived>::TransformQualifiedNameType( 2019 const QualifiedNameType *T) { 2020 NestedNameSpecifier *NNS 2021 = getDerived().TransformNestedNameSpecifier(T->getQualifier(), 2022 SourceRange()); 2023 if (!NNS) 2024 return QualType(); 2025 2026 QualType Named = getDerived().TransformType(T->getNamedType()); 2027 if (Named.isNull()) 2028 return QualType(); 2029 2030 if (!getDerived().AlwaysRebuild() && 2031 NNS == T->getQualifier() && 2032 Named == T->getNamedType()) 2033 return QualType(T, 0); 2034 2035 return getDerived().RebuildQualifiedNameType(NNS, Named); 2036} 2037 2038template<typename Derived> 2039QualType TreeTransform<Derived>::TransformTypenameType(const TypenameType *T) { 2040 NestedNameSpecifier *NNS 2041 = getDerived().TransformNestedNameSpecifier(T->getQualifier(), 2042 SourceRange(/*FIXME:*/getDerived().getBaseLocation())); 2043 if (!NNS) 2044 return QualType(); 2045 2046 if (const TemplateSpecializationType *TemplateId = T->getTemplateId()) { 2047 QualType NewTemplateId 2048 = getDerived().TransformType(QualType(TemplateId, 0)); 2049 if (NewTemplateId.isNull()) 2050 return QualType(); 2051 2052 if (!getDerived().AlwaysRebuild() && 2053 NNS == T->getQualifier() && 2054 NewTemplateId == QualType(TemplateId, 0)) 2055 return QualType(T, 0); 2056 2057 return getDerived().RebuildTypenameType(NNS, NewTemplateId); 2058 } 2059 2060 return getDerived().RebuildTypenameType(NNS, T->getIdentifier()); 2061} 2062 2063template<typename Derived> 2064QualType TreeTransform<Derived>::TransformObjCInterfaceType( 2065 const ObjCInterfaceType *T) { 2066 // FIXME: Implement 2067 return QualType(T, 0); 2068} 2069 2070template<typename Derived> 2071QualType TreeTransform<Derived>::TransformObjCObjectPointerType( 2072 const ObjCObjectPointerType *T) { 2073 // FIXME: Implement 2074 return QualType(T, 0); 2075} 2076 2077//===----------------------------------------------------------------------===// 2078// Expression transformation 2079//===----------------------------------------------------------------------===// 2080template<typename Derived> 2081Sema::OwningExprResult 2082TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) { 2083 return SemaRef.Owned(E->Retain()); 2084} 2085 2086template<typename Derived> 2087Sema::OwningExprResult 2088TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) { 2089 NamedDecl *ND 2090 = dyn_cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getDecl())); 2091 if (!ND) 2092 return SemaRef.ExprError(); 2093 2094 if (!getDerived().AlwaysRebuild() && ND == E->getDecl()) 2095 return SemaRef.Owned(E->Retain()); 2096 2097 return getDerived().RebuildDeclRefExpr(ND, E->getLocation()); 2098} 2099 2100template<typename Derived> 2101Sema::OwningExprResult 2102TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) { 2103 return SemaRef.Owned(E->Retain()); 2104} 2105 2106template<typename Derived> 2107Sema::OwningExprResult 2108TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) { 2109 return SemaRef.Owned(E->Retain()); 2110} 2111 2112template<typename Derived> 2113Sema::OwningExprResult 2114TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) { 2115 return SemaRef.Owned(E->Retain()); 2116} 2117 2118template<typename Derived> 2119Sema::OwningExprResult 2120TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) { 2121 return SemaRef.Owned(E->Retain()); 2122} 2123 2124template<typename Derived> 2125Sema::OwningExprResult 2126TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) { 2127 return SemaRef.Owned(E->Retain()); 2128} 2129 2130template<typename Derived> 2131Sema::OwningExprResult 2132TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) { 2133 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 2134 if (SubExpr.isInvalid()) 2135 return SemaRef.ExprError(); 2136 2137 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 2138 return SemaRef.Owned(E->Retain()); 2139 2140 return getDerived().RebuildParenExpr(move(SubExpr), E->getLParen(), 2141 E->getRParen()); 2142} 2143 2144template<typename Derived> 2145Sema::OwningExprResult 2146TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) { 2147 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 2148 if (SubExpr.isInvalid()) 2149 return SemaRef.ExprError(); 2150 2151 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 2152 return SemaRef.Owned(E->Retain()); 2153 2154 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(), 2155 E->getOpcode(), 2156 move(SubExpr)); 2157} 2158 2159template<typename Derived> 2160Sema::OwningExprResult 2161TreeTransform<Derived>::TransformSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { 2162 if (E->isArgumentType()) { 2163 QualType T = getDerived().TransformType(E->getArgumentType()); 2164 if (T.isNull()) 2165 return SemaRef.ExprError(); 2166 2167 if (!getDerived().AlwaysRebuild() && T == E->getArgumentType()) 2168 return SemaRef.Owned(E->Retain()); 2169 2170 return getDerived().RebuildSizeOfAlignOf(T, E->getOperatorLoc(), 2171 E->isSizeOf(), 2172 E->getSourceRange()); 2173 } 2174 2175 Sema::OwningExprResult SubExpr(SemaRef); 2176 { 2177 // C++0x [expr.sizeof]p1: 2178 // The operand is either an expression, which is an unevaluated operand 2179 // [...] 2180 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2181 2182 SubExpr = getDerived().TransformExpr(E->getArgumentExpr()); 2183 if (SubExpr.isInvalid()) 2184 return SemaRef.ExprError(); 2185 2186 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr()) 2187 return SemaRef.Owned(E->Retain()); 2188 } 2189 2190 return getDerived().RebuildSizeOfAlignOf(move(SubExpr), E->getOperatorLoc(), 2191 E->isSizeOf(), 2192 E->getSourceRange()); 2193} 2194 2195template<typename Derived> 2196Sema::OwningExprResult 2197TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) { 2198 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 2199 if (LHS.isInvalid()) 2200 return SemaRef.ExprError(); 2201 2202 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 2203 if (RHS.isInvalid()) 2204 return SemaRef.ExprError(); 2205 2206 2207 if (!getDerived().AlwaysRebuild() && 2208 LHS.get() == E->getLHS() && 2209 RHS.get() == E->getRHS()) 2210 return SemaRef.Owned(E->Retain()); 2211 2212 return getDerived().RebuildArraySubscriptExpr(move(LHS), 2213 /*FIXME:*/E->getLHS()->getLocStart(), 2214 move(RHS), 2215 E->getRBracketLoc()); 2216} 2217 2218template<typename Derived> 2219Sema::OwningExprResult 2220TreeTransform<Derived>::TransformCallExpr(CallExpr *E) { 2221 // Transform the callee. 2222 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee()); 2223 if (Callee.isInvalid()) 2224 return SemaRef.ExprError(); 2225 2226 // Transform arguments. 2227 bool ArgChanged = false; 2228 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 2229 llvm::SmallVector<SourceLocation, 4> FakeCommaLocs; 2230 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) { 2231 OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I)); 2232 if (Arg.isInvalid()) 2233 return SemaRef.ExprError(); 2234 2235 // FIXME: Wrong source location information for the ','. 2236 FakeCommaLocs.push_back( 2237 SemaRef.PP.getLocForEndOfToken(E->getArg(I)->getSourceRange().getEnd())); 2238 2239 ArgChanged = ArgChanged || Arg.get() != E->getArg(I); 2240 Args.push_back(Arg.takeAs<Expr>()); 2241 } 2242 2243 if (!getDerived().AlwaysRebuild() && 2244 Callee.get() == E->getCallee() && 2245 !ArgChanged) 2246 return SemaRef.Owned(E->Retain()); 2247 2248 // FIXME: Wrong source location information for the '('. 2249 SourceLocation FakeLParenLoc 2250 = ((Expr *)Callee.get())->getSourceRange().getBegin(); 2251 return getDerived().RebuildCallExpr(move(Callee), FakeLParenLoc, 2252 move_arg(Args), 2253 FakeCommaLocs.data(), 2254 E->getRParenLoc()); 2255} 2256 2257template<typename Derived> 2258Sema::OwningExprResult 2259TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) { 2260 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 2261 if (Base.isInvalid()) 2262 return SemaRef.ExprError(); 2263 2264 NamedDecl *Member 2265 = cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getMemberDecl())); 2266 if (!Member) 2267 return SemaRef.ExprError(); 2268 2269 if (!getDerived().AlwaysRebuild() && 2270 Base.get() == E->getBase() && 2271 Member == E->getMemberDecl()) 2272 return SemaRef.Owned(E->Retain()); 2273 2274 // FIXME: Bogus source location for the operator 2275 SourceLocation FakeOperatorLoc 2276 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd()); 2277 2278 return getDerived().RebuildMemberExpr(move(Base), FakeOperatorLoc, 2279 E->isArrow(), 2280 E->getMemberLoc(), 2281 Member); 2282} 2283 2284template<typename Derived> 2285Sema::OwningExprResult 2286TreeTransform<Derived>::TransformCastExpr(CastExpr *E) { 2287 assert(false && "Cannot transform abstract class"); 2288 return SemaRef.Owned(E->Retain()); 2289} 2290 2291template<typename Derived> 2292Sema::OwningExprResult 2293TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) { 2294 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 2295 if (LHS.isInvalid()) 2296 return SemaRef.ExprError(); 2297 2298 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 2299 if (RHS.isInvalid()) 2300 return SemaRef.ExprError(); 2301 2302 if (!getDerived().AlwaysRebuild() && 2303 LHS.get() == E->getLHS() && 2304 RHS.get() == E->getRHS()) 2305 return SemaRef.Owned(E->Retain()); 2306 2307 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(), 2308 move(LHS), move(RHS)); 2309} 2310 2311template<typename Derived> 2312Sema::OwningExprResult 2313TreeTransform<Derived>::TransformCompoundAssignOperator( 2314 CompoundAssignOperator *E) { 2315 return getDerived().TransformBinaryOperator(E); 2316} 2317 2318template<typename Derived> 2319Sema::OwningExprResult 2320TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) { 2321 OwningExprResult Cond = getDerived().TransformExpr(E->getCond()); 2322 if (Cond.isInvalid()) 2323 return SemaRef.ExprError(); 2324 2325 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 2326 if (LHS.isInvalid()) 2327 return SemaRef.ExprError(); 2328 2329 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 2330 if (RHS.isInvalid()) 2331 return SemaRef.ExprError(); 2332 2333 if (!getDerived().AlwaysRebuild() && 2334 Cond.get() == E->getCond() && 2335 LHS.get() == E->getLHS() && 2336 RHS.get() == E->getRHS()) 2337 return SemaRef.Owned(E->Retain()); 2338 2339 // FIXM: ? and : locations are broken. 2340 SourceLocation FakeQuestionLoc = E->getCond()->getLocEnd(); 2341 SourceLocation FakeColonLoc = E->getFalseExpr()->getLocStart(); 2342 return getDerived().RebuildConditionalOperator(move(Cond), 2343 FakeQuestionLoc, 2344 move(LHS), 2345 FakeColonLoc, 2346 move(RHS)); 2347} 2348 2349template<typename Derived> 2350Sema::OwningExprResult 2351TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) { 2352 QualType T = getDerived().TransformType(E->getType()); 2353 if (T.isNull()) 2354 return SemaRef.ExprError(); 2355 2356 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 2357 if (SubExpr.isInvalid()) 2358 return SemaRef.ExprError(); 2359 2360 if (!getDerived().AlwaysRebuild() && 2361 T == E->getType() && 2362 SubExpr.get() == E->getSubExpr()) 2363 return SemaRef.Owned(E->Retain()); 2364 2365 return getDerived().RebuildImplicitCastExpr(T, E->getCastKind(), 2366 move(SubExpr), 2367 E->isLvalueCast()); 2368} 2369 2370template<typename Derived> 2371Sema::OwningExprResult 2372TreeTransform<Derived>::TransformExplicitCastExpr(ExplicitCastExpr *E) { 2373 assert(false && "Cannot transform abstract class"); 2374 return SemaRef.Owned(E->Retain()); 2375} 2376 2377template<typename Derived> 2378Sema::OwningExprResult 2379TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) { 2380 QualType T; 2381 { 2382 // FIXME: Source location isn't quite accurate. 2383 SourceLocation TypeStartLoc 2384 = SemaRef.PP.getLocForEndOfToken(E->getLParenLoc()); 2385 TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName()); 2386 2387 T = getDerived().TransformType(E->getTypeAsWritten()); 2388 if (T.isNull()) 2389 return SemaRef.ExprError(); 2390 } 2391 2392 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 2393 if (SubExpr.isInvalid()) 2394 return SemaRef.ExprError(); 2395 2396 if (!getDerived().AlwaysRebuild() && 2397 T == E->getTypeAsWritten() && 2398 SubExpr.get() == E->getSubExpr()) 2399 return SemaRef.Owned(E->Retain()); 2400 2401 return getDerived().RebuildCStyleCaseExpr(E->getLParenLoc(), T, 2402 E->getRParenLoc(), 2403 move(SubExpr)); 2404} 2405 2406template<typename Derived> 2407Sema::OwningExprResult 2408TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) { 2409 QualType T; 2410 { 2411 // FIXME: Source location isn't quite accurate. 2412 SourceLocation FakeTypeLoc 2413 = SemaRef.PP.getLocForEndOfToken(E->getLParenLoc()); 2414 TemporaryBase Rebase(*this, FakeTypeLoc, DeclarationName()); 2415 2416 T = getDerived().TransformType(E->getType()); 2417 if (T.isNull()) 2418 return SemaRef.ExprError(); 2419 } 2420 2421 OwningExprResult Init = getDerived().TransformExpr(E->getInitializer()); 2422 if (Init.isInvalid()) 2423 return SemaRef.ExprError(); 2424 2425 if (!getDerived().AlwaysRebuild() && 2426 T == E->getType() && 2427 Init.get() == E->getInitializer()) 2428 return SemaRef.Owned(E->Retain()); 2429 2430 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), T, 2431 /*FIXME:*/E->getInitializer()->getLocEnd(), 2432 move(Init)); 2433} 2434 2435template<typename Derived> 2436Sema::OwningExprResult 2437TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) { 2438 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 2439 if (Base.isInvalid()) 2440 return SemaRef.ExprError(); 2441 2442 if (!getDerived().AlwaysRebuild() && 2443 Base.get() == E->getBase()) 2444 return SemaRef.Owned(E->Retain()); 2445 2446 // FIXME: Bad source location 2447 SourceLocation FakeOperatorLoc 2448 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getLocEnd()); 2449 return getDerived().RebuildExtVectorElementExpr(move(Base), FakeOperatorLoc, 2450 E->getAccessorLoc(), 2451 E->getAccessor()); 2452} 2453 2454template<typename Derived> 2455Sema::OwningExprResult 2456TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) { 2457 bool InitChanged = false; 2458 2459 ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef); 2460 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) { 2461 OwningExprResult Init = getDerived().TransformExpr(E->getInit(I)); 2462 if (Init.isInvalid()) 2463 return SemaRef.ExprError(); 2464 2465 InitChanged = InitChanged || Init.get() != E->getInit(I); 2466 Inits.push_back(Init.takeAs<Expr>()); 2467 } 2468 2469 if (!getDerived().AlwaysRebuild() && !InitChanged) 2470 return SemaRef.Owned(E->Retain()); 2471 2472 return getDerived().RebuildInitList(E->getLBraceLoc(), move_arg(Inits), 2473 E->getRBraceLoc()); 2474} 2475 2476template<typename Derived> 2477Sema::OwningExprResult 2478TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { 2479 Designation Desig; 2480 2481 // Instantiate the initializer value 2482 OwningExprResult Init = getDerived().TransformExpr(E->getInit()); 2483 if (Init.isInvalid()) 2484 return SemaRef.ExprError(); 2485 2486 // Instantiate the designators. 2487 ASTOwningVector<&ActionBase::DeleteExpr, 4> ArrayExprs(SemaRef); 2488 bool ExprChanged = false; 2489 for (DesignatedInitExpr::designators_iterator D = E->designators_begin(), 2490 DEnd = E->designators_end(); 2491 D != DEnd; ++D) { 2492 if (D->isFieldDesignator()) { 2493 Desig.AddDesignator(Designator::getField(D->getFieldName(), 2494 D->getDotLoc(), 2495 D->getFieldLoc())); 2496 continue; 2497 } 2498 2499 if (D->isArrayDesignator()) { 2500 OwningExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D)); 2501 if (Index.isInvalid()) 2502 return SemaRef.ExprError(); 2503 2504 Desig.AddDesignator(Designator::getArray(Index.get(), 2505 D->getLBracketLoc())); 2506 2507 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D); 2508 ArrayExprs.push_back(Index.release()); 2509 continue; 2510 } 2511 2512 assert(D->isArrayRangeDesignator() && "New kind of designator?"); 2513 OwningExprResult Start 2514 = getDerived().TransformExpr(E->getArrayRangeStart(*D)); 2515 if (Start.isInvalid()) 2516 return SemaRef.ExprError(); 2517 2518 OwningExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D)); 2519 if (End.isInvalid()) 2520 return SemaRef.ExprError(); 2521 2522 Desig.AddDesignator(Designator::getArrayRange(Start.get(), 2523 End.get(), 2524 D->getLBracketLoc(), 2525 D->getEllipsisLoc())); 2526 2527 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) || 2528 End.get() != E->getArrayRangeEnd(*D); 2529 2530 ArrayExprs.push_back(Start.release()); 2531 ArrayExprs.push_back(End.release()); 2532 } 2533 2534 if (!getDerived().AlwaysRebuild() && 2535 Init.get() == E->getInit() && 2536 !ExprChanged) 2537 return SemaRef.Owned(E->Retain()); 2538 2539 return getDerived().RebuildDesignatedInitExpr(Desig, move_arg(ArrayExprs), 2540 E->getEqualOrColonLoc(), 2541 E->usesGNUSyntax(), move(Init)); 2542} 2543 2544template<typename Derived> 2545Sema::OwningExprResult 2546TreeTransform<Derived>::TransformImplicitValueInitExpr( 2547 ImplicitValueInitExpr *E) { 2548 QualType T = getDerived().TransformType(E->getType()); 2549 if (T.isNull()) 2550 return SemaRef.ExprError(); 2551 2552 if (!getDerived().AlwaysRebuild() && 2553 T == E->getType()) 2554 return SemaRef.Owned(E->Retain()); 2555 2556 return getDerived().RebuildImplicitValueInitExpr(T); 2557} 2558 2559template<typename Derived> 2560Sema::OwningExprResult 2561TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) { 2562 // FIXME: Do we want the type as written? 2563 QualType T; 2564 2565 { 2566 // FIXME: Source location isn't quite accurate. 2567 TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName()); 2568 T = getDerived().TransformType(E->getType()); 2569 if (T.isNull()) 2570 return SemaRef.ExprError(); 2571 } 2572 2573 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 2574 if (SubExpr.isInvalid()) 2575 return SemaRef.ExprError(); 2576 2577 if (!getDerived().AlwaysRebuild() && 2578 T == E->getType() && 2579 SubExpr.get() == E->getSubExpr()) 2580 return SemaRef.Owned(E->Retain()); 2581 2582 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), move(SubExpr), 2583 T, E->getRParenLoc()); 2584} 2585 2586template<typename Derived> 2587Sema::OwningExprResult 2588TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) { 2589 bool ArgumentChanged = false; 2590 ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef); 2591 for (unsigned I = 0, N = E->getNumExprs(); I != N; ++I) { 2592 OwningExprResult Init = getDerived().TransformExpr(E->getExpr(I)); 2593 if (Init.isInvalid()) 2594 return SemaRef.ExprError(); 2595 2596 ArgumentChanged = ArgumentChanged || Init.get() != E->getExpr(I); 2597 Inits.push_back(Init.takeAs<Expr>()); 2598 } 2599 2600 return getDerived().RebuildParenListExpr(E->getLParenLoc(), 2601 move_arg(Inits), 2602 E->getRParenLoc()); 2603} 2604 2605/// \brief Transform an address-of-label expression. 2606/// 2607/// By default, the transformation of an address-of-label expression always 2608/// rebuilds the expression, so that the label identifier can be resolved to 2609/// the corresponding label statement by semantic analysis. 2610template<typename Derived> 2611Sema::OwningExprResult 2612TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) { 2613 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(), 2614 E->getLabel()); 2615} 2616 2617template<typename Derived> 2618Sema::OwningExprResult TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) { 2619 OwningStmtResult SubStmt 2620 = getDerived().TransformCompoundStmt(E->getSubStmt(), true); 2621 if (SubStmt.isInvalid()) 2622 return SemaRef.ExprError(); 2623 2624 if (!getDerived().AlwaysRebuild() && 2625 SubStmt.get() == E->getSubStmt()) 2626 return SemaRef.Owned(E->Retain()); 2627 2628 return getDerived().RebuildStmtExpr(E->getLParenLoc(), 2629 move(SubStmt), 2630 E->getRParenLoc()); 2631} 2632 2633template<typename Derived> 2634Sema::OwningExprResult 2635TreeTransform<Derived>::TransformTypesCompatibleExpr(TypesCompatibleExpr *E) { 2636 QualType T1, T2; 2637 { 2638 // FIXME: Source location isn't quite accurate. 2639 TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName()); 2640 2641 T1 = getDerived().TransformType(E->getArgType1()); 2642 if (T1.isNull()) 2643 return SemaRef.ExprError(); 2644 2645 T2 = getDerived().TransformType(E->getArgType2()); 2646 if (T2.isNull()) 2647 return SemaRef.ExprError(); 2648 } 2649 2650 if (!getDerived().AlwaysRebuild() && 2651 T1 == E->getArgType1() && 2652 T2 == E->getArgType2()) 2653 return SemaRef.Owned(E->Retain()); 2654 2655 return getDerived().RebuildTypesCompatibleExpr(E->getBuiltinLoc(), 2656 T1, T2, E->getRParenLoc()); 2657} 2658 2659template<typename Derived> 2660Sema::OwningExprResult 2661TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) { 2662 OwningExprResult Cond = getDerived().TransformExpr(E->getCond()); 2663 if (Cond.isInvalid()) 2664 return SemaRef.ExprError(); 2665 2666 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 2667 if (LHS.isInvalid()) 2668 return SemaRef.ExprError(); 2669 2670 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 2671 if (RHS.isInvalid()) 2672 return SemaRef.ExprError(); 2673 2674 if (!getDerived().AlwaysRebuild() && 2675 Cond.get() == E->getCond() && 2676 LHS.get() == E->getLHS() && 2677 RHS.get() == E->getRHS()) 2678 return SemaRef.Owned(E->Retain()); 2679 2680 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(), 2681 move(Cond), move(LHS), move(RHS), 2682 E->getRParenLoc()); 2683} 2684 2685template<typename Derived> 2686Sema::OwningExprResult 2687TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) { 2688 return SemaRef.Owned(E->Retain()); 2689} 2690 2691template<typename Derived> 2692Sema::OwningExprResult 2693TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 2694 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee()); 2695 if (Callee.isInvalid()) 2696 return SemaRef.ExprError(); 2697 2698 OwningExprResult First = getDerived().TransformExpr(E->getArg(0)); 2699 if (First.isInvalid()) 2700 return SemaRef.ExprError(); 2701 2702 OwningExprResult Second(SemaRef); 2703 if (E->getNumArgs() == 2) { 2704 Second = getDerived().TransformExpr(E->getArg(1)); 2705 if (Second.isInvalid()) 2706 return SemaRef.ExprError(); 2707 } 2708 2709 if (!getDerived().AlwaysRebuild() && 2710 Callee.get() == E->getCallee() && 2711 First.get() == E->getArg(0) && 2712 (E->getNumArgs() != 2 || Second.get() == E->getArg(1))) 2713 return SemaRef.Owned(E->Retain()); 2714 2715 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(), 2716 E->getOperatorLoc(), 2717 move(Callee), 2718 move(First), 2719 move(Second)); 2720} 2721 2722template<typename Derived> 2723Sema::OwningExprResult 2724TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) { 2725 return getDerived().TransformCallExpr(E); 2726} 2727 2728template<typename Derived> 2729Sema::OwningExprResult 2730TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) { 2731 QualType ExplicitTy; 2732 { 2733 // FIXME: Source location isn't quite accurate. 2734 SourceLocation TypeStartLoc 2735 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc()); 2736 TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName()); 2737 2738 ExplicitTy = getDerived().TransformType(E->getTypeAsWritten()); 2739 if (ExplicitTy.isNull()) 2740 return SemaRef.ExprError(); 2741 } 2742 2743 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 2744 if (SubExpr.isInvalid()) 2745 return SemaRef.ExprError(); 2746 2747 if (!getDerived().AlwaysRebuild() && 2748 ExplicitTy == E->getTypeAsWritten() && 2749 SubExpr.get() == E->getSubExpr()) 2750 return SemaRef.Owned(E->Retain()); 2751 2752 // FIXME: Poor source location information here. 2753 SourceLocation FakeLAngleLoc 2754 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc()); 2755 SourceLocation FakeRAngleLoc = E->getSubExpr()->getSourceRange().getBegin(); 2756 SourceLocation FakeRParenLoc 2757 = SemaRef.PP.getLocForEndOfToken( 2758 E->getSubExpr()->getSourceRange().getEnd()); 2759 return getDerived().RebuildCXXNamedCastExpr(E->getOperatorLoc(), 2760 E->getStmtClass(), 2761 FakeLAngleLoc, 2762 ExplicitTy, 2763 FakeRAngleLoc, 2764 FakeRAngleLoc, 2765 move(SubExpr), 2766 FakeRParenLoc); 2767} 2768 2769template<typename Derived> 2770Sema::OwningExprResult 2771TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) { 2772 return getDerived().TransformCXXNamedCastExpr(E); 2773} 2774 2775template<typename Derived> 2776Sema::OwningExprResult 2777TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) { 2778 return getDerived().TransformCXXNamedCastExpr(E); 2779} 2780 2781template<typename Derived> 2782Sema::OwningExprResult 2783TreeTransform<Derived>::TransformCXXReinterpretCastExpr( 2784 CXXReinterpretCastExpr *E) { 2785 return getDerived().TransformCXXNamedCastExpr(E); 2786} 2787 2788template<typename Derived> 2789Sema::OwningExprResult 2790TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) { 2791 return getDerived().TransformCXXNamedCastExpr(E); 2792} 2793 2794template<typename Derived> 2795Sema::OwningExprResult 2796TreeTransform<Derived>::TransformCXXFunctionalCastExpr( 2797 CXXFunctionalCastExpr *E) { 2798 QualType ExplicitTy; 2799 { 2800 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 2801 2802 ExplicitTy = getDerived().TransformType(E->getTypeAsWritten()); 2803 if (ExplicitTy.isNull()) 2804 return SemaRef.ExprError(); 2805 } 2806 2807 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 2808 if (SubExpr.isInvalid()) 2809 return SemaRef.ExprError(); 2810 2811 if (!getDerived().AlwaysRebuild() && 2812 ExplicitTy == E->getTypeAsWritten() && 2813 SubExpr.get() == E->getSubExpr()) 2814 return SemaRef.Owned(E->Retain()); 2815 2816 // FIXME: The end of the type's source range is wrong 2817 return getDerived().RebuildCXXFunctionalCastExpr( 2818 /*FIXME:*/SourceRange(E->getTypeBeginLoc()), 2819 ExplicitTy, 2820 /*FIXME:*/E->getSubExpr()->getLocStart(), 2821 move(SubExpr), 2822 E->getRParenLoc()); 2823} 2824 2825template<typename Derived> 2826Sema::OwningExprResult 2827TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) { 2828 if (E->isTypeOperand()) { 2829 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 2830 2831 QualType T = getDerived().TransformType(E->getTypeOperand()); 2832 if (T.isNull()) 2833 return SemaRef.ExprError(); 2834 2835 if (!getDerived().AlwaysRebuild() && 2836 T == E->getTypeOperand()) 2837 return SemaRef.Owned(E->Retain()); 2838 2839 return getDerived().RebuildCXXTypeidExpr(E->getLocStart(), 2840 /*FIXME:*/E->getLocStart(), 2841 T, 2842 E->getLocEnd()); 2843 } 2844 2845 // We don't know whether the expression is potentially evaluated until 2846 // after we perform semantic analysis, so the expression is potentially 2847 // potentially evaluated. 2848 EnterExpressionEvaluationContext Unevaluated(SemaRef, 2849 Action::PotentiallyPotentiallyEvaluated); 2850 2851 OwningExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); 2852 if (SubExpr.isInvalid()) 2853 return SemaRef.ExprError(); 2854 2855 if (!getDerived().AlwaysRebuild() && 2856 SubExpr.get() == E->getExprOperand()) 2857 return SemaRef.Owned(E->Retain()); 2858 2859 return getDerived().RebuildCXXTypeidExpr(E->getLocStart(), 2860 /*FIXME:*/E->getLocStart(), 2861 move(SubExpr), 2862 E->getLocEnd()); 2863} 2864 2865template<typename Derived> 2866Sema::OwningExprResult 2867TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 2868 return SemaRef.Owned(E->Retain()); 2869} 2870 2871template<typename Derived> 2872Sema::OwningExprResult 2873TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr( 2874 CXXNullPtrLiteralExpr *E) { 2875 return SemaRef.Owned(E->Retain()); 2876} 2877 2878template<typename Derived> 2879Sema::OwningExprResult 2880TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) { 2881 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 2882 2883 QualType T = getDerived().TransformType(E->getType()); 2884 if (T.isNull()) 2885 return SemaRef.ExprError(); 2886 2887 if (!getDerived().AlwaysRebuild() && 2888 T == E->getType()) 2889 return SemaRef.Owned(E->Retain()); 2890 2891 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T); 2892} 2893 2894template<typename Derived> 2895Sema::OwningExprResult 2896TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) { 2897 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 2898 if (SubExpr.isInvalid()) 2899 return SemaRef.ExprError(); 2900 2901 if (!getDerived().AlwaysRebuild() && 2902 SubExpr.get() == E->getSubExpr()) 2903 return SemaRef.Owned(E->Retain()); 2904 2905 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), move(SubExpr)); 2906} 2907 2908template<typename Derived> 2909Sema::OwningExprResult 2910TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 2911 ParmVarDecl *Param 2912 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getParam())); 2913 if (!Param) 2914 return SemaRef.ExprError(); 2915 2916 if (getDerived().AlwaysRebuild() && 2917 Param == E->getParam()) 2918 return SemaRef.Owned(E->Retain()); 2919 2920 return getDerived().RebuildCXXDefaultArgExpr(Param); 2921} 2922 2923template<typename Derived> 2924Sema::OwningExprResult 2925TreeTransform<Derived>::TransformCXXZeroInitValueExpr(CXXZeroInitValueExpr *E) { 2926 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 2927 2928 QualType T = getDerived().TransformType(E->getType()); 2929 if (T.isNull()) 2930 return SemaRef.ExprError(); 2931 2932 if (!getDerived().AlwaysRebuild() && 2933 T == E->getType()) 2934 return SemaRef.Owned(E->Retain()); 2935 2936 return getDerived().RebuildCXXZeroInitValueExpr(E->getTypeBeginLoc(), 2937 /*FIXME:*/E->getTypeBeginLoc(), 2938 T, 2939 E->getRParenLoc()); 2940} 2941 2942template<typename Derived> 2943Sema::OwningExprResult 2944TreeTransform<Derived>::TransformCXXConditionDeclExpr(CXXConditionDeclExpr *E) { 2945 VarDecl *Var 2946 = cast_or_null<VarDecl>(getDerived().TransformDecl(E->getVarDecl())); 2947 if (!Var) 2948 return SemaRef.ExprError(); 2949 2950 if (!getDerived().AlwaysRebuild() && 2951 Var == E->getVarDecl()) 2952 return SemaRef.Owned(E->Retain()); 2953 2954 return getDerived().RebuildCXXConditionDeclExpr(E->getStartLoc(), 2955 /*FIXME:*/E->getStartLoc(), 2956 Var); 2957} 2958 2959template<typename Derived> 2960Sema::OwningExprResult 2961TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { 2962 // Transform the type that we're allocating 2963 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 2964 QualType AllocType = getDerived().TransformType(E->getAllocatedType()); 2965 if (AllocType.isNull()) 2966 return SemaRef.ExprError(); 2967 2968 // Transform the size of the array we're allocating (if any). 2969 OwningExprResult ArraySize = getDerived().TransformExpr(E->getArraySize()); 2970 if (ArraySize.isInvalid()) 2971 return SemaRef.ExprError(); 2972 2973 // Transform the placement arguments (if any). 2974 bool ArgumentChanged = false; 2975 ASTOwningVector<&ActionBase::DeleteExpr> PlacementArgs(SemaRef); 2976 for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) { 2977 OwningExprResult Arg = getDerived().TransformExpr(E->getPlacementArg(I)); 2978 if (Arg.isInvalid()) 2979 return SemaRef.ExprError(); 2980 2981 ArgumentChanged = ArgumentChanged || Arg.get() != E->getPlacementArg(I); 2982 PlacementArgs.push_back(Arg.take()); 2983 } 2984 2985 // Instantiate the constructor arguments (if any). 2986 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(SemaRef); 2987 for (unsigned I = 0, N = E->getNumConstructorArgs(); I != N; ++I) { 2988 OwningExprResult Arg = getDerived().TransformExpr(E->getConstructorArg(I)); 2989 if (Arg.isInvalid()) 2990 return SemaRef.ExprError(); 2991 2992 ArgumentChanged = ArgumentChanged || Arg.get() != E->getConstructorArg(I); 2993 ConstructorArgs.push_back(Arg.take()); 2994 } 2995 2996 if (!getDerived().AlwaysRebuild() && 2997 AllocType == E->getAllocatedType() && 2998 ArraySize.get() == E->getArraySize() && 2999 !ArgumentChanged) 3000 return SemaRef.Owned(E->Retain()); 3001 3002 return getDerived().RebuildCXXNewExpr(E->getLocStart(), 3003 E->isGlobalNew(), 3004 /*FIXME:*/E->getLocStart(), 3005 move_arg(PlacementArgs), 3006 /*FIXME:*/E->getLocStart(), 3007 E->isParenTypeId(), 3008 AllocType, 3009 /*FIXME:*/E->getLocStart(), 3010 /*FIXME:*/SourceRange(), 3011 move(ArraySize), 3012 /*FIXME:*/E->getLocStart(), 3013 move_arg(ConstructorArgs), 3014 E->getLocEnd()); 3015} 3016 3017template<typename Derived> 3018Sema::OwningExprResult 3019TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) { 3020 OwningExprResult Operand = getDerived().TransformExpr(E->getArgument()); 3021 if (Operand.isInvalid()) 3022 return SemaRef.ExprError(); 3023 3024 if (!getDerived().AlwaysRebuild() && 3025 Operand.get() == E->getArgument()) 3026 return SemaRef.Owned(E->Retain()); 3027 3028 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(), 3029 E->isGlobalDelete(), 3030 E->isArrayForm(), 3031 move(Operand)); 3032} 3033 3034template<typename Derived> 3035Sema::OwningExprResult 3036TreeTransform<Derived>::TransformUnresolvedFunctionNameExpr( 3037 UnresolvedFunctionNameExpr *E) { 3038 // There is no transformation we can apply to an unresolved function name. 3039 return SemaRef.Owned(E->Retain()); 3040} 3041 3042template<typename Derived> 3043Sema::OwningExprResult 3044TreeTransform<Derived>::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { 3045 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 3046 3047 QualType T = getDerived().TransformType(E->getQueriedType()); 3048 if (T.isNull()) 3049 return SemaRef.ExprError(); 3050 3051 if (!getDerived().AlwaysRebuild() && 3052 T == E->getQueriedType()) 3053 return SemaRef.Owned(E->Retain()); 3054 3055 // FIXME: Bad location information 3056 SourceLocation FakeLParenLoc 3057 = SemaRef.PP.getLocForEndOfToken(E->getLocStart()); 3058 3059 return getDerived().RebuildUnaryTypeTrait(E->getTrait(), 3060 E->getLocStart(), 3061 /*FIXME:*/FakeLParenLoc, 3062 T, 3063 E->getLocEnd()); 3064} 3065 3066template<typename Derived> 3067Sema::OwningExprResult 3068TreeTransform<Derived>::TransformQualifiedDeclRefExpr(QualifiedDeclRefExpr *E) { 3069 NestedNameSpecifier *NNS 3070 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 3071 E->getQualifierRange()); 3072 if (!NNS) 3073 return SemaRef.ExprError(); 3074 3075 NamedDecl *ND 3076 = dyn_cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getDecl())); 3077 if (!ND) 3078 return SemaRef.ExprError(); 3079 3080 if (!getDerived().AlwaysRebuild() && 3081 NNS == E->getQualifier() && 3082 ND == E->getDecl()) 3083 return SemaRef.Owned(E->Retain()); 3084 3085 return getDerived().RebuildQualifiedDeclRefExpr(NNS, 3086 E->getQualifierRange(), 3087 ND, 3088 E->getLocation(), 3089 /*FIXME:*/false); 3090} 3091 3092template<typename Derived> 3093Sema::OwningExprResult 3094TreeTransform<Derived>::TransformUnresolvedDeclRefExpr( 3095 UnresolvedDeclRefExpr *E) { 3096 NestedNameSpecifier *NNS 3097 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 3098 E->getQualifierRange()); 3099 if (!NNS) 3100 return SemaRef.ExprError(); 3101 3102 // FIXME: Transform the declaration name 3103 DeclarationName Name = E->getDeclName(); 3104 3105 if (!getDerived().AlwaysRebuild() && 3106 NNS == E->getQualifier() && 3107 Name == E->getDeclName()) 3108 return SemaRef.Owned(E->Retain()); 3109 3110 return getDerived().RebuildUnresolvedDeclRefExpr(NNS, 3111 E->getQualifierRange(), 3112 Name, 3113 E->getLocation(), 3114 /*FIXME:*/false); 3115} 3116 3117template<typename Derived> 3118Sema::OwningExprResult 3119TreeTransform<Derived>::TransformTemplateIdRefExpr(TemplateIdRefExpr *E) { 3120 TemplateName Template 3121 = getDerived().TransformTemplateName(E->getTemplateName()); 3122 if (Template.isNull()) 3123 return SemaRef.ExprError(); 3124 3125 llvm::SmallVector<TemplateArgument, 4> TransArgs; 3126 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 3127 TemplateArgument TransArg 3128 = getDerived().TransformTemplateArgument(E->getTemplateArgs()[I]); 3129 if (TransArg.isNull()) 3130 return SemaRef.ExprError(); 3131 3132 TransArgs.push_back(TransArg); 3133 } 3134 3135 // FIXME: Would like to avoid rebuilding if nothing changed, but we can't 3136 // compare template arguments (yet). 3137 3138 // FIXME: It's possible that we'll find out now that the template name 3139 // actually refers to a type, in which case the caller is actually dealing 3140 // with a functional cast. Give a reasonable error message! 3141 return getDerived().RebuildTemplateIdExpr(Template, E->getTemplateNameLoc(), 3142 E->getLAngleLoc(), 3143 TransArgs.data(), 3144 TransArgs.size(), 3145 E->getRAngleLoc()); 3146} 3147 3148template<typename Derived> 3149Sema::OwningExprResult 3150TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) { 3151 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 3152 3153 QualType T = getDerived().TransformType(E->getType()); 3154 if (T.isNull()) 3155 return SemaRef.ExprError(); 3156 3157 CXXConstructorDecl *Constructor 3158 = cast_or_null<CXXConstructorDecl>( 3159 getDerived().TransformDecl(E->getConstructor())); 3160 if (!Constructor) 3161 return SemaRef.ExprError(); 3162 3163 bool ArgumentChanged = false; 3164 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 3165 for (CXXConstructExpr::arg_iterator Arg = E->arg_begin(), 3166 ArgEnd = E->arg_end(); 3167 Arg != ArgEnd; ++Arg) { 3168 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 3169 if (TransArg.isInvalid()) 3170 return SemaRef.ExprError(); 3171 3172 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 3173 Args.push_back(TransArg.takeAs<Expr>()); 3174 } 3175 3176 if (!getDerived().AlwaysRebuild() && 3177 T == E->getType() && 3178 Constructor == E->getConstructor() && 3179 !ArgumentChanged) 3180 return SemaRef.Owned(E->Retain()); 3181 3182 return getDerived().RebuildCXXConstructExpr(T, Constructor, E->isElidable(), 3183 move_arg(Args)); 3184} 3185 3186/// \brief Transform a C++ temporary-binding expression. 3187/// 3188/// The transformation of a temporary-binding expression always attempts to 3189/// bind a new temporary variable to its subexpression, even if the 3190/// subexpression itself did not change, because the temporary variable itself 3191/// must be unique. 3192template<typename Derived> 3193Sema::OwningExprResult 3194TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 3195 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 3196 if (SubExpr.isInvalid()) 3197 return SemaRef.ExprError(); 3198 3199 return SemaRef.MaybeBindToTemporary(SubExpr.takeAs<Expr>()); 3200} 3201 3202/// \brief Transform a C++ expression that contains temporaries that should 3203/// be destroyed after the expression is evaluated. 3204/// 3205/// The transformation of a full expression always attempts to build a new 3206/// CXXExprWithTemporaries expression, even if the 3207/// subexpression itself did not change, because it will need to capture the 3208/// the new temporary variables introduced in the subexpression. 3209template<typename Derived> 3210Sema::OwningExprResult 3211TreeTransform<Derived>::TransformCXXExprWithTemporaries( 3212 CXXExprWithTemporaries *E) { 3213 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 3214 if (SubExpr.isInvalid()) 3215 return SemaRef.ExprError(); 3216 3217 return SemaRef.Owned( 3218 SemaRef.MaybeCreateCXXExprWithTemporaries(SubExpr.takeAs<Expr>(), 3219 E->shouldDestroyTemporaries())); 3220} 3221 3222template<typename Derived> 3223Sema::OwningExprResult 3224TreeTransform<Derived>::TransformCXXTemporaryObjectExpr( 3225 CXXTemporaryObjectExpr *E) { 3226 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 3227 QualType T = getDerived().TransformType(E->getType()); 3228 if (T.isNull()) 3229 return SemaRef.ExprError(); 3230 3231 CXXConstructorDecl *Constructor 3232 = cast_or_null<CXXConstructorDecl>( 3233 getDerived().TransformDecl(E->getConstructor())); 3234 if (!Constructor) 3235 return SemaRef.ExprError(); 3236 3237 bool ArgumentChanged = false; 3238 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 3239 Args.reserve(E->getNumArgs()); 3240 for (CXXTemporaryObjectExpr::arg_iterator Arg = E->arg_begin(), 3241 ArgEnd = E->arg_end(); 3242 Arg != ArgEnd; ++Arg) { 3243 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 3244 if (TransArg.isInvalid()) 3245 return SemaRef.ExprError(); 3246 3247 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 3248 Args.push_back((Expr *)TransArg.release()); 3249 } 3250 3251 if (!getDerived().AlwaysRebuild() && 3252 T == E->getType() && 3253 Constructor == E->getConstructor() && 3254 !ArgumentChanged) 3255 return SemaRef.Owned(E->Retain()); 3256 3257 // FIXME: Bogus location information 3258 SourceLocation CommaLoc; 3259 if (Args.size() > 1) { 3260 Expr *First = (Expr *)Args[0]; 3261 CommaLoc 3262 = SemaRef.PP.getLocForEndOfToken(First->getSourceRange().getEnd()); 3263 } 3264 return getDerived().RebuildCXXTemporaryObjectExpr(E->getTypeBeginLoc(), 3265 T, 3266 /*FIXME:*/E->getTypeBeginLoc(), 3267 move_arg(Args), 3268 &CommaLoc, 3269 E->getLocEnd()); 3270} 3271 3272template<typename Derived> 3273Sema::OwningExprResult 3274TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( 3275 CXXUnresolvedConstructExpr *E) { 3276 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 3277 QualType T = getDerived().TransformType(E->getTypeAsWritten()); 3278 if (T.isNull()) 3279 return SemaRef.ExprError(); 3280 3281 bool ArgumentChanged = false; 3282 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 3283 llvm::SmallVector<SourceLocation, 8> FakeCommaLocs; 3284 for (CXXUnresolvedConstructExpr::arg_iterator Arg = E->arg_begin(), 3285 ArgEnd = E->arg_end(); 3286 Arg != ArgEnd; ++Arg) { 3287 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 3288 if (TransArg.isInvalid()) 3289 return SemaRef.ExprError(); 3290 3291 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 3292 FakeCommaLocs.push_back( 3293 SemaRef.PP.getLocForEndOfToken((*Arg)->getLocEnd())); 3294 Args.push_back(TransArg.takeAs<Expr>()); 3295 } 3296 3297 if (!getDerived().AlwaysRebuild() && 3298 T == E->getTypeAsWritten() && 3299 !ArgumentChanged) 3300 return SemaRef.Owned(E->Retain()); 3301 3302 // FIXME: we're faking the locations of the commas 3303 return getDerived().RebuildCXXUnresolvedConstructExpr(E->getTypeBeginLoc(), 3304 T, 3305 E->getLParenLoc(), 3306 move_arg(Args), 3307 FakeCommaLocs.data(), 3308 E->getRParenLoc()); 3309} 3310 3311template<typename Derived> 3312Sema::OwningExprResult 3313TreeTransform<Derived>::TransformCXXUnresolvedMemberExpr( 3314 CXXUnresolvedMemberExpr *E) { 3315 // Transform the base of the expression. 3316 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 3317 if (Base.isInvalid()) 3318 return SemaRef.ExprError(); 3319 3320 // FIXME: Transform the declaration name 3321 DeclarationName Name = E->getMember(); 3322 3323 if (!getDerived().AlwaysRebuild() && 3324 Base.get() == E->getBase() && 3325 Name == E->getMember()) 3326 return SemaRef.Owned(E->Retain()); 3327 3328 return getDerived().RebuildCXXUnresolvedMemberExpr(move(Base), 3329 E->isArrow(), 3330 E->getOperatorLoc(), 3331 E->getMember(), 3332 E->getMemberLoc()); 3333} 3334 3335template<typename Derived> 3336Sema::OwningExprResult 3337TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) { 3338 return SemaRef.Owned(E->Retain()); 3339} 3340 3341template<typename Derived> 3342Sema::OwningExprResult 3343TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) { 3344 // FIXME: poor source location 3345 TemporaryBase Rebase(*this, E->getAtLoc(), DeclarationName()); 3346 QualType EncodedType = getDerived().TransformType(E->getEncodedType()); 3347 if (EncodedType.isNull()) 3348 return SemaRef.ExprError(); 3349 3350 if (!getDerived().AlwaysRebuild() && 3351 EncodedType == E->getEncodedType()) 3352 return SemaRef.Owned(E->Retain()); 3353 3354 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(), 3355 EncodedType, 3356 E->getRParenLoc()); 3357} 3358 3359template<typename Derived> 3360Sema::OwningExprResult 3361TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) { 3362 // FIXME: Implement this! 3363 assert(false && "Cannot transform Objective-C expressions yet"); 3364 return SemaRef.Owned(E->Retain()); 3365} 3366 3367template<typename Derived> 3368Sema::OwningExprResult 3369TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) { 3370 return SemaRef.Owned(E->Retain()); 3371} 3372 3373template<typename Derived> 3374Sema::OwningExprResult 3375TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) { 3376 ObjCProtocolDecl *Protocol 3377 = cast_or_null<ObjCProtocolDecl>( 3378 getDerived().TransformDecl(E->getProtocol())); 3379 if (!Protocol) 3380 return SemaRef.ExprError(); 3381 3382 if (!getDerived().AlwaysRebuild() && 3383 Protocol == E->getProtocol()) 3384 return SemaRef.Owned(E->Retain()); 3385 3386 return getDerived().RebuildObjCProtocolExpr(Protocol, 3387 E->getAtLoc(), 3388 /*FIXME:*/E->getAtLoc(), 3389 /*FIXME:*/E->getAtLoc(), 3390 E->getRParenLoc()); 3391 3392} 3393 3394template<typename Derived> 3395Sema::OwningExprResult 3396TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) { 3397 // FIXME: Implement this! 3398 assert(false && "Cannot transform Objective-C expressions yet"); 3399 return SemaRef.Owned(E->Retain()); 3400} 3401 3402template<typename Derived> 3403Sema::OwningExprResult 3404TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 3405 // FIXME: Implement this! 3406 assert(false && "Cannot transform Objective-C expressions yet"); 3407 return SemaRef.Owned(E->Retain()); 3408} 3409 3410template<typename Derived> 3411Sema::OwningExprResult 3412TreeTransform<Derived>::TransformObjCImplctSetterGetterRefExpr( 3413 ObjCImplctSetterGetterRefExpr *E) { 3414 // FIXME: Implement this! 3415 assert(false && "Cannot transform Objective-C expressions yet"); 3416 return SemaRef.Owned(E->Retain()); 3417} 3418 3419template<typename Derived> 3420Sema::OwningExprResult 3421TreeTransform<Derived>::TransformObjCSuperExpr(ObjCSuperExpr *E) { 3422 // FIXME: Implement this! 3423 assert(false && "Cannot transform Objective-C expressions yet"); 3424 return SemaRef.Owned(E->Retain()); 3425} 3426 3427template<typename Derived> 3428Sema::OwningExprResult 3429TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) { 3430 // FIXME: Implement this! 3431 assert(false && "Cannot transform Objective-C expressions yet"); 3432 return SemaRef.Owned(E->Retain()); 3433} 3434 3435template<typename Derived> 3436Sema::OwningExprResult 3437TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) { 3438 bool ArgumentChanged = false; 3439 ASTOwningVector<&ActionBase::DeleteExpr> SubExprs(SemaRef); 3440 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) { 3441 OwningExprResult SubExpr = getDerived().TransformExpr(E->getExpr(I)); 3442 if (SubExpr.isInvalid()) 3443 return SemaRef.ExprError(); 3444 3445 ArgumentChanged = ArgumentChanged || SubExpr.get() != E->getExpr(I); 3446 SubExprs.push_back(SubExpr.takeAs<Expr>()); 3447 } 3448 3449 if (!getDerived().AlwaysRebuild() && 3450 !ArgumentChanged) 3451 return SemaRef.Owned(E->Retain()); 3452 3453 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(), 3454 move_arg(SubExprs), 3455 E->getRParenLoc()); 3456} 3457 3458template<typename Derived> 3459Sema::OwningExprResult 3460TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { 3461 // FIXME: Implement this! 3462 assert(false && "Cannot transform block expressions yet"); 3463 return SemaRef.Owned(E->Retain()); 3464} 3465 3466template<typename Derived> 3467Sema::OwningExprResult 3468TreeTransform<Derived>::TransformBlockDeclRefExpr(BlockDeclRefExpr *E) { 3469 // FIXME: Implement this! 3470 assert(false && "Cannot transform block-related expressions yet"); 3471 return SemaRef.Owned(E->Retain()); 3472} 3473 3474//===----------------------------------------------------------------------===// 3475// Type reconstruction 3476//===----------------------------------------------------------------------===// 3477 3478template<typename Derived> 3479QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType) { 3480 return SemaRef.BuildPointerType(PointeeType, 0, 3481 getDerived().getBaseLocation(), 3482 getDerived().getBaseEntity()); 3483} 3484 3485template<typename Derived> 3486QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType) { 3487 return SemaRef.BuildBlockPointerType(PointeeType, 0, 3488 getDerived().getBaseLocation(), 3489 getDerived().getBaseEntity()); 3490} 3491 3492template<typename Derived> 3493QualType 3494TreeTransform<Derived>::RebuildLValueReferenceType(QualType ReferentType) { 3495 return SemaRef.BuildReferenceType(ReferentType, true, 0, 3496 getDerived().getBaseLocation(), 3497 getDerived().getBaseEntity()); 3498} 3499 3500template<typename Derived> 3501QualType 3502TreeTransform<Derived>::RebuildRValueReferenceType(QualType ReferentType) { 3503 return SemaRef.BuildReferenceType(ReferentType, false, 0, 3504 getDerived().getBaseLocation(), 3505 getDerived().getBaseEntity()); 3506} 3507 3508template<typename Derived> 3509QualType TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType, 3510 QualType ClassType) { 3511 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, 0, 3512 getDerived().getBaseLocation(), 3513 getDerived().getBaseEntity()); 3514} 3515 3516template<typename Derived> 3517QualType 3518TreeTransform<Derived>::RebuildArrayType(QualType ElementType, 3519 ArrayType::ArraySizeModifier SizeMod, 3520 const llvm::APInt *Size, 3521 Expr *SizeExpr, 3522 unsigned IndexTypeQuals, 3523 SourceRange BracketsRange) { 3524 if (SizeExpr || !Size) 3525 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr, 3526 IndexTypeQuals, BracketsRange, 3527 getDerived().getBaseEntity()); 3528 3529 QualType Types[] = { 3530 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy, 3531 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, 3532 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty 3533 }; 3534 const unsigned NumTypes = sizeof(Types) / sizeof(QualType); 3535 QualType SizeType; 3536 for (unsigned I = 0; I != NumTypes; ++I) 3537 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) { 3538 SizeType = Types[I]; 3539 break; 3540 } 3541 3542 if (SizeType.isNull()) 3543 SizeType = SemaRef.Context.getFixedWidthIntType(Size->getBitWidth(), false); 3544 3545 IntegerLiteral ArraySize(*Size, SizeType, /*FIXME*/BracketsRange.getBegin()); 3546 return SemaRef.BuildArrayType(ElementType, SizeMod, &ArraySize, 3547 IndexTypeQuals, BracketsRange, 3548 getDerived().getBaseEntity()); 3549} 3550 3551template<typename Derived> 3552QualType 3553TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType, 3554 ArrayType::ArraySizeModifier SizeMod, 3555 const llvm::APInt &Size, 3556 unsigned IndexTypeQuals) { 3557 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0, 3558 IndexTypeQuals, SourceRange()); 3559} 3560 3561template<typename Derived> 3562QualType 3563TreeTransform<Derived>::RebuildConstantArrayWithExprType(QualType ElementType, 3564 ArrayType::ArraySizeModifier SizeMod, 3565 const llvm::APInt &Size, 3566 Expr *SizeExpr, 3567 unsigned IndexTypeQuals, 3568 SourceRange BracketsRange) { 3569 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, SizeExpr, 3570 IndexTypeQuals, BracketsRange); 3571} 3572 3573template<typename Derived> 3574QualType 3575TreeTransform<Derived>::RebuildConstantArrayWithoutExprType( 3576 QualType ElementType, 3577 ArrayType::ArraySizeModifier SizeMod, 3578 const llvm::APInt &Size, 3579 unsigned IndexTypeQuals) { 3580 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0, 3581 IndexTypeQuals, SourceRange()); 3582} 3583 3584template<typename Derived> 3585QualType 3586TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType, 3587 ArrayType::ArraySizeModifier SizeMod, 3588 unsigned IndexTypeQuals) { 3589 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 0, 3590 IndexTypeQuals, SourceRange()); 3591} 3592 3593template<typename Derived> 3594QualType 3595TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType, 3596 ArrayType::ArraySizeModifier SizeMod, 3597 ExprArg SizeExpr, 3598 unsigned IndexTypeQuals, 3599 SourceRange BracketsRange) { 3600 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 3601 SizeExpr.takeAs<Expr>(), 3602 IndexTypeQuals, BracketsRange); 3603} 3604 3605template<typename Derived> 3606QualType 3607TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType, 3608 ArrayType::ArraySizeModifier SizeMod, 3609 ExprArg SizeExpr, 3610 unsigned IndexTypeQuals, 3611 SourceRange BracketsRange) { 3612 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 3613 SizeExpr.takeAs<Expr>(), 3614 IndexTypeQuals, BracketsRange); 3615} 3616 3617template<typename Derived> 3618QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType, 3619 unsigned NumElements) { 3620 // FIXME: semantic checking! 3621 return SemaRef.Context.getVectorType(ElementType, NumElements); 3622} 3623 3624template<typename Derived> 3625QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType, 3626 unsigned NumElements, 3627 SourceLocation AttributeLoc) { 3628 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy), 3629 NumElements, true); 3630 IntegerLiteral *VectorSize 3631 = new (SemaRef.Context) IntegerLiteral(numElements, SemaRef.Context.IntTy, 3632 AttributeLoc); 3633 return SemaRef.BuildExtVectorType(ElementType, SemaRef.Owned(VectorSize), 3634 AttributeLoc); 3635} 3636 3637template<typename Derived> 3638QualType 3639TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType, 3640 ExprArg SizeExpr, 3641 SourceLocation AttributeLoc) { 3642 return SemaRef.BuildExtVectorType(ElementType, move(SizeExpr), AttributeLoc); 3643} 3644 3645template<typename Derived> 3646QualType TreeTransform<Derived>::RebuildFunctionProtoType(QualType T, 3647 QualType *ParamTypes, 3648 unsigned NumParamTypes, 3649 bool Variadic, 3650 unsigned Quals) { 3651 return SemaRef.BuildFunctionType(T, ParamTypes, NumParamTypes, Variadic, 3652 Quals, 3653 getDerived().getBaseLocation(), 3654 getDerived().getBaseEntity()); 3655} 3656 3657template<typename Derived> 3658QualType TreeTransform<Derived>::RebuildTypeOfExprType(ExprArg E) { 3659 return SemaRef.BuildTypeofExprType(E.takeAs<Expr>()); 3660} 3661 3662template<typename Derived> 3663QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) { 3664 return SemaRef.Context.getTypeOfType(Underlying); 3665} 3666 3667template<typename Derived> 3668QualType TreeTransform<Derived>::RebuildDecltypeType(ExprArg E) { 3669 return SemaRef.BuildDecltypeType(E.takeAs<Expr>()); 3670} 3671 3672template<typename Derived> 3673QualType TreeTransform<Derived>::RebuildTemplateSpecializationType( 3674 TemplateName Template, 3675 const TemplateArgument *Args, 3676 unsigned NumArgs) { 3677 // FIXME: Missing source locations for the template name, <, >. 3678 return SemaRef.CheckTemplateIdType(Template, getDerived().getBaseLocation(), 3679 SourceLocation(), Args, NumArgs, 3680 SourceLocation()); 3681} 3682 3683template<typename Derived> 3684NestedNameSpecifier * 3685TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 3686 SourceRange Range, 3687 IdentifierInfo &II) { 3688 CXXScopeSpec SS; 3689 // FIXME: The source location information is all wrong. 3690 SS.setRange(Range); 3691 SS.setScopeRep(Prefix); 3692 return static_cast<NestedNameSpecifier *>( 3693 SemaRef.ActOnCXXNestedNameSpecifier(0, SS, Range.getEnd(), 3694 Range.getEnd(), II)); 3695} 3696 3697template<typename Derived> 3698NestedNameSpecifier * 3699TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 3700 SourceRange Range, 3701 NamespaceDecl *NS) { 3702 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, NS); 3703} 3704 3705template<typename Derived> 3706NestedNameSpecifier * 3707TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 3708 SourceRange Range, 3709 bool TemplateKW, 3710 QualType T) { 3711 if (T->isDependentType() || T->isRecordType() || 3712 (SemaRef.getLangOptions().CPlusPlus0x && T->isEnumeralType())) { 3713 assert(T.getCVRQualifiers() == 0 && "Can't get cv-qualifiers here"); 3714 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, TemplateKW, 3715 T.getTypePtr()); 3716 } 3717 3718 SemaRef.Diag(Range.getBegin(), diag::err_nested_name_spec_non_tag) << T; 3719 return 0; 3720} 3721 3722template<typename Derived> 3723TemplateName 3724TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 3725 bool TemplateKW, 3726 TemplateDecl *Template) { 3727 return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW, 3728 Template); 3729} 3730 3731template<typename Derived> 3732TemplateName 3733TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 3734 bool TemplateKW, 3735 OverloadedFunctionDecl *Ovl) { 3736 return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW, Ovl); 3737} 3738 3739template<typename Derived> 3740TemplateName 3741TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 3742 const IdentifierInfo &II) { 3743 if (Qualifier->isDependent()) 3744 return SemaRef.Context.getDependentTemplateName(Qualifier, &II); 3745 3746 // Somewhat redundant with ActOnDependentTemplateName. 3747 CXXScopeSpec SS; 3748 SS.setRange(SourceRange(getDerived().getBaseLocation())); 3749 SS.setScopeRep(Qualifier); 3750 Sema::TemplateTy Template; 3751 TemplateNameKind TNK = SemaRef.isTemplateName(II, 0, Template, &SS); 3752 if (TNK == TNK_Non_template) { 3753 SemaRef.Diag(getDerived().getBaseLocation(), 3754 diag::err_template_kw_refers_to_non_template) 3755 << &II; 3756 return TemplateName(); 3757 } else if (TNK == TNK_Function_template) { 3758 SemaRef.Diag(getDerived().getBaseLocation(), 3759 diag::err_template_kw_refers_to_non_template) 3760 << &II; 3761 return TemplateName(); 3762 } 3763 3764 return Template.getAsVal<TemplateName>(); 3765} 3766 3767template<typename Derived> 3768Sema::OwningExprResult 3769TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, 3770 SourceLocation OpLoc, 3771 ExprArg Callee, 3772 ExprArg First, 3773 ExprArg Second) { 3774 Expr *FirstExpr = (Expr *)First.get(); 3775 Expr *SecondExpr = (Expr *)Second.get(); 3776 bool isPostIncDec = SecondExpr && (Op == OO_PlusPlus || Op == OO_MinusMinus); 3777 3778 // Determine whether this should be a builtin operation. 3779 if (SecondExpr == 0 || isPostIncDec) { 3780 if (!FirstExpr->getType()->isOverloadableType()) { 3781 // The argument is not of overloadable type, so try to create a 3782 // built-in unary operation. 3783 UnaryOperator::Opcode Opc 3784 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 3785 3786 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, move(First)); 3787 } 3788 } else { 3789 if (!FirstExpr->getType()->isOverloadableType() && 3790 !SecondExpr->getType()->isOverloadableType()) { 3791 // Neither of the arguments is an overloadable type, so try to 3792 // create a built-in binary operation. 3793 BinaryOperator::Opcode Opc = BinaryOperator::getOverloadedOpcode(Op); 3794 OwningExprResult Result 3795 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, FirstExpr, SecondExpr); 3796 if (Result.isInvalid()) 3797 return SemaRef.ExprError(); 3798 3799 First.release(); 3800 Second.release(); 3801 return move(Result); 3802 } 3803 } 3804 3805 // Compute the transformed set of functions (and function templates) to be 3806 // used during overload resolution. 3807 Sema::FunctionSet Functions; 3808 3809 DeclRefExpr *DRE = cast<DeclRefExpr>((Expr *)Callee.get()); 3810 OverloadedFunctionDecl *Overloads 3811 = cast<OverloadedFunctionDecl>(DRE->getDecl()); 3812 3813 // FIXME: Do we have to check 3814 // IsAcceptableNonMemberOperatorCandidate for each of these? 3815 for (OverloadedFunctionDecl::function_iterator 3816 F = Overloads->function_begin(), 3817 FEnd = Overloads->function_end(); 3818 F != FEnd; ++F) 3819 Functions.insert(*F); 3820 3821 // Add any functions found via argument-dependent lookup. 3822 Expr *Args[2] = { FirstExpr, SecondExpr }; 3823 unsigned NumArgs = 1 + (SecondExpr != 0); 3824 DeclarationName OpName 3825 = SemaRef.Context.DeclarationNames.getCXXOperatorName(Op); 3826 SemaRef.ArgumentDependentLookup(OpName, Args, NumArgs, Functions); 3827 3828 // Create the overloaded operator invocation for unary operators. 3829 if (NumArgs == 1 || isPostIncDec) { 3830 UnaryOperator::Opcode Opc 3831 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 3832 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, move(First)); 3833 } 3834 3835 // Create the overloaded operator invocation for binary operators. 3836 BinaryOperator::Opcode Opc = 3837 BinaryOperator::getOverloadedOpcode(Op); 3838 OwningExprResult Result 3839 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]); 3840 if (Result.isInvalid()) 3841 return SemaRef.ExprError(); 3842 3843 First.release(); 3844 Second.release(); 3845 return move(Result); 3846} 3847 3848} // end namespace clang 3849 3850#endif // LLVM_CLANG_SEMA_TREETRANSFORM_H 3851