TreeTransform.h revision f1480eee38b59d15438fb7bc50865ac7c7e22403
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(getSema().Context, T, 1177 Constructor, 1178 IsElidable, 1179 ArgsExprs, 1180 NumArgs)); 1181 } 1182 1183 /// \brief Build a new object-construction expression. 1184 /// 1185 /// By default, performs semantic analysis to build the new expression. 1186 /// Subclasses may override this routine to provide different behavior. 1187 OwningExprResult RebuildCXXTemporaryObjectExpr(SourceLocation TypeBeginLoc, 1188 QualType T, 1189 SourceLocation LParenLoc, 1190 MultiExprArg Args, 1191 SourceLocation *Commas, 1192 SourceLocation RParenLoc) { 1193 return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeBeginLoc), 1194 T.getAsOpaquePtr(), 1195 LParenLoc, 1196 move(Args), 1197 Commas, 1198 RParenLoc); 1199 } 1200 1201 /// \brief Build a new object-construction expression. 1202 /// 1203 /// By default, performs semantic analysis to build the new expression. 1204 /// Subclasses may override this routine to provide different behavior. 1205 OwningExprResult RebuildCXXUnresolvedConstructExpr(SourceLocation TypeBeginLoc, 1206 QualType T, 1207 SourceLocation LParenLoc, 1208 MultiExprArg Args, 1209 SourceLocation *Commas, 1210 SourceLocation RParenLoc) { 1211 return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeBeginLoc, 1212 /*FIXME*/LParenLoc), 1213 T.getAsOpaquePtr(), 1214 LParenLoc, 1215 move(Args), 1216 Commas, 1217 RParenLoc); 1218 } 1219 1220 /// \brief Build a new member reference expression. 1221 /// 1222 /// By default, performs semantic analysis to build the new expression. 1223 /// Subclasses may override this routine to provide different behavior. 1224 OwningExprResult RebuildCXXUnresolvedMemberExpr(ExprArg BaseE, 1225 bool IsArrow, 1226 SourceLocation OperatorLoc, 1227 DeclarationName Name, 1228 SourceLocation MemberLoc) { 1229 OwningExprResult Base = move(BaseE); 1230 tok::TokenKind OpKind = IsArrow? tok::arrow : tok::period; 1231 CXXScopeSpec SS; 1232 Base = SemaRef.ActOnCXXEnterMemberScope(0, SS, move(Base), OpKind); 1233 if (Base.isInvalid()) 1234 return SemaRef.ExprError(); 1235 1236 assert(Name.getAsIdentifierInfo() && 1237 "Cannot transform member references with non-identifier members"); 1238 Base = SemaRef.ActOnMemberReferenceExpr(/*Scope=*/0, 1239 move(Base), OperatorLoc, OpKind, 1240 MemberLoc, 1241 *Name.getAsIdentifierInfo(), 1242 /*FIXME?*/Sema::DeclPtrTy::make((Decl*)0)); 1243 SemaRef.ActOnCXXExitMemberScope(0, SS); 1244 return move(Base); 1245 } 1246 1247 /// \brief Build a new Objective-C @encode expression. 1248 /// 1249 /// By default, performs semantic analysis to build the new expression. 1250 /// Subclasses may override this routine to provide different behavior. 1251 OwningExprResult RebuildObjCEncodeExpr(SourceLocation AtLoc, 1252 QualType T, 1253 SourceLocation RParenLoc) { 1254 return SemaRef.Owned(SemaRef.BuildObjCEncodeExpression(AtLoc, T, 1255 RParenLoc)); 1256 } 1257 1258 /// \brief Build a new Objective-C protocol expression. 1259 /// 1260 /// By default, performs semantic analysis to build the new expression. 1261 /// Subclasses may override this routine to provide different behavior. 1262 OwningExprResult RebuildObjCProtocolExpr(ObjCProtocolDecl *Protocol, 1263 SourceLocation AtLoc, 1264 SourceLocation ProtoLoc, 1265 SourceLocation LParenLoc, 1266 SourceLocation RParenLoc) { 1267 return SemaRef.Owned(SemaRef.ParseObjCProtocolExpression( 1268 Protocol->getIdentifier(), 1269 AtLoc, 1270 ProtoLoc, 1271 LParenLoc, 1272 RParenLoc)); 1273 } 1274 1275 /// \brief Build a new shuffle vector expression. 1276 /// 1277 /// By default, performs semantic analysis to build the new expression. 1278 /// Subclasses may override this routine to provide different behavior. 1279 OwningExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc, 1280 MultiExprArg SubExprs, 1281 SourceLocation RParenLoc) { 1282 // Find the declaration for __builtin_shufflevector 1283 const IdentifierInfo &Name 1284 = SemaRef.Context.Idents.get("__builtin_shufflevector"); 1285 TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl(); 1286 DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name)); 1287 assert(Lookup.first != Lookup.second && "No __builtin_shufflevector?"); 1288 1289 // Build a reference to the __builtin_shufflevector builtin 1290 FunctionDecl *Builtin = cast<FunctionDecl>(*Lookup.first); 1291 Expr *Callee 1292 = new (SemaRef.Context) DeclRefExpr(Builtin, Builtin->getType(), 1293 BuiltinLoc, false, false); 1294 SemaRef.UsualUnaryConversions(Callee); 1295 1296 // Build the CallExpr 1297 unsigned NumSubExprs = SubExprs.size(); 1298 Expr **Subs = (Expr **)SubExprs.release(); 1299 CallExpr *TheCall = new (SemaRef.Context) CallExpr(SemaRef.Context, Callee, 1300 Subs, NumSubExprs, 1301 Builtin->getResultType(), 1302 RParenLoc); 1303 OwningExprResult OwnedCall(SemaRef.Owned(TheCall)); 1304 1305 // Type-check the __builtin_shufflevector expression. 1306 OwningExprResult Result = SemaRef.SemaBuiltinShuffleVector(TheCall); 1307 if (Result.isInvalid()) 1308 return SemaRef.ExprError(); 1309 1310 OwnedCall.release(); 1311 return move(Result); 1312 } 1313}; 1314 1315 1316template<typename Derived> 1317Sema::OwningExprResult TreeTransform<Derived>::TransformExpr(Expr *E, 1318 bool isAddressOfOperand) { 1319 if (!E) 1320 return SemaRef.Owned(E); 1321 1322 switch (E->getStmtClass()) { 1323 case Stmt::NoStmtClass: break; 1324#define STMT(Node, Parent) case Stmt::Node##Class: break; 1325#define EXPR(Node, Parent) \ 1326 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E)); 1327#include "clang/AST/StmtNodes.def" 1328 } 1329 1330 return SemaRef.Owned(E->Retain()); 1331} 1332 1333template<typename Derived> 1334NestedNameSpecifier * 1335TreeTransform<Derived>::TransformNestedNameSpecifier(NestedNameSpecifier *NNS, 1336 SourceRange Range) { 1337 // Instantiate the prefix of this nested name specifier. 1338 NestedNameSpecifier *Prefix = NNS->getPrefix(); 1339 if (Prefix) { 1340 Prefix = getDerived().TransformNestedNameSpecifier(Prefix, Range); 1341 if (!Prefix) 1342 return 0; 1343 } 1344 1345 switch (NNS->getKind()) { 1346 case NestedNameSpecifier::Identifier: 1347 assert(Prefix && 1348 "Can't have an identifier nested-name-specifier with no prefix"); 1349 if (!getDerived().AlwaysRebuild() && Prefix == NNS->getPrefix()) 1350 return NNS; 1351 1352 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, 1353 *NNS->getAsIdentifier()); 1354 1355 case NestedNameSpecifier::Namespace: { 1356 NamespaceDecl *NS 1357 = cast_or_null<NamespaceDecl>( 1358 getDerived().TransformDecl(NNS->getAsNamespace())); 1359 if (!getDerived().AlwaysRebuild() && 1360 Prefix == NNS->getPrefix() && 1361 NS == NNS->getAsNamespace()) 1362 return NNS; 1363 1364 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, NS); 1365 } 1366 1367 case NestedNameSpecifier::Global: 1368 // There is no meaningful transformation that one could perform on the 1369 // global scope. 1370 return NNS; 1371 1372 case NestedNameSpecifier::TypeSpecWithTemplate: 1373 case NestedNameSpecifier::TypeSpec: { 1374 QualType T = getDerived().TransformType(QualType(NNS->getAsType(), 0)); 1375 if (T.isNull()) 1376 return 0; 1377 1378 if (!getDerived().AlwaysRebuild() && 1379 Prefix == NNS->getPrefix() && 1380 T == QualType(NNS->getAsType(), 0)) 1381 return NNS; 1382 1383 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, 1384 NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate, 1385 T); 1386 } 1387 } 1388 1389 // Required to silence a GCC warning 1390 return 0; 1391} 1392 1393template<typename Derived> 1394TemplateName 1395TreeTransform<Derived>::TransformTemplateName(TemplateName Name) { 1396 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) { 1397 NestedNameSpecifier *NNS 1398 = getDerived().TransformNestedNameSpecifier(QTN->getQualifier(), 1399 /*FIXME:*/SourceRange(getDerived().getBaseLocation())); 1400 if (!NNS) 1401 return TemplateName(); 1402 1403 if (TemplateDecl *Template = QTN->getTemplateDecl()) { 1404 TemplateDecl *TransTemplate 1405 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Template)); 1406 if (!TransTemplate) 1407 return TemplateName(); 1408 1409 if (!getDerived().AlwaysRebuild() && 1410 NNS == QTN->getQualifier() && 1411 TransTemplate == Template) 1412 return Name; 1413 1414 return getDerived().RebuildTemplateName(NNS, QTN->hasTemplateKeyword(), 1415 TransTemplate); 1416 } 1417 1418 OverloadedFunctionDecl *Ovl = QTN->getOverloadedFunctionDecl(); 1419 assert(Ovl && "Not a template name or an overload set?"); 1420 OverloadedFunctionDecl *TransOvl 1421 = cast_or_null<OverloadedFunctionDecl>(getDerived().TransformDecl(Ovl)); 1422 if (!TransOvl) 1423 return TemplateName(); 1424 1425 if (!getDerived().AlwaysRebuild() && 1426 NNS == QTN->getQualifier() && 1427 TransOvl == Ovl) 1428 return Name; 1429 1430 return getDerived().RebuildTemplateName(NNS, QTN->hasTemplateKeyword(), 1431 TransOvl); 1432 } 1433 1434 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) { 1435 NestedNameSpecifier *NNS 1436 = getDerived().TransformNestedNameSpecifier(DTN->getQualifier(), 1437 /*FIXME:*/SourceRange(getDerived().getBaseLocation())); 1438 if (!NNS) 1439 return TemplateName(); 1440 1441 if (!getDerived().AlwaysRebuild() && 1442 NNS == DTN->getQualifier()) 1443 return Name; 1444 1445 return getDerived().RebuildTemplateName(NNS, *DTN->getName()); 1446 } 1447 1448 if (TemplateDecl *Template = Name.getAsTemplateDecl()) { 1449 TemplateDecl *TransTemplate 1450 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Template)); 1451 if (!TransTemplate) 1452 return TemplateName(); 1453 1454 if (!getDerived().AlwaysRebuild() && 1455 TransTemplate == Template) 1456 return Name; 1457 1458 return TemplateName(TransTemplate); 1459 } 1460 1461 OverloadedFunctionDecl *Ovl = Name.getAsOverloadedFunctionDecl(); 1462 assert(Ovl && "Not a template name or an overload set?"); 1463 OverloadedFunctionDecl *TransOvl 1464 = cast_or_null<OverloadedFunctionDecl>(getDerived().TransformDecl(Ovl)); 1465 if (!TransOvl) 1466 return TemplateName(); 1467 1468 if (!getDerived().AlwaysRebuild() && 1469 TransOvl == Ovl) 1470 return Name; 1471 1472 return TemplateName(TransOvl); 1473} 1474 1475template<typename Derived> 1476TemplateArgument 1477TreeTransform<Derived>::TransformTemplateArgument(const TemplateArgument &Arg) { 1478 switch (Arg.getKind()) { 1479 case TemplateArgument::Null: 1480 case TemplateArgument::Integral: 1481 return Arg; 1482 1483 case TemplateArgument::Type: { 1484 QualType T = getDerived().TransformType(Arg.getAsType()); 1485 if (T.isNull()) 1486 return TemplateArgument(); 1487 return TemplateArgument(Arg.getLocation(), T); 1488 } 1489 1490 case TemplateArgument::Declaration: { 1491 Decl *D = getDerived().TransformDecl(Arg.getAsDecl()); 1492 if (!D) 1493 return TemplateArgument(); 1494 return TemplateArgument(Arg.getLocation(), D); 1495 } 1496 1497 case TemplateArgument::Expression: { 1498 // Template argument expressions are not potentially evaluated. 1499 EnterExpressionEvaluationContext Unevaluated(getSema(), 1500 Action::Unevaluated); 1501 1502 Sema::OwningExprResult E = getDerived().TransformExpr(Arg.getAsExpr()); 1503 if (E.isInvalid()) 1504 return TemplateArgument(); 1505 return TemplateArgument(E.takeAs<Expr>()); 1506 } 1507 1508 case TemplateArgument::Pack: { 1509 llvm::SmallVector<TemplateArgument, 4> TransformedArgs; 1510 TransformedArgs.reserve(Arg.pack_size()); 1511 for (TemplateArgument::pack_iterator A = Arg.pack_begin(), 1512 AEnd = Arg.pack_end(); 1513 A != AEnd; ++A) { 1514 TemplateArgument TA = getDerived().TransformTemplateArgument(*A); 1515 if (TA.isNull()) 1516 return TA; 1517 1518 TransformedArgs.push_back(TA); 1519 } 1520 TemplateArgument Result; 1521 Result.setArgumentPack(TransformedArgs.data(), TransformedArgs.size(), 1522 true); 1523 return Result; 1524 } 1525 } 1526 1527 // Work around bogus GCC warning 1528 return TemplateArgument(); 1529} 1530 1531//===----------------------------------------------------------------------===// 1532// Type transformation 1533//===----------------------------------------------------------------------===// 1534 1535template<typename Derived> 1536QualType TreeTransform<Derived>::TransformType(QualType T) { 1537 if (getDerived().AlreadyTransformed(T)) 1538 return T; 1539 1540 QualType Result; 1541 switch (T->getTypeClass()) { 1542#define ABSTRACT_TYPE(CLASS, PARENT) 1543#define TYPE(CLASS, PARENT) \ 1544 case Type::CLASS: \ 1545 Result = getDerived().Transform##CLASS##Type( \ 1546 static_cast<CLASS##Type*>(T.getTypePtr())); \ 1547 break; 1548#include "clang/AST/TypeNodes.def" 1549 } 1550 1551 if (Result.isNull() || T == Result) 1552 return Result; 1553 1554 return getDerived().AddTypeQualifiers(Result, T.getCVRQualifiers()); 1555} 1556 1557template<typename Derived> 1558QualType 1559TreeTransform<Derived>::AddTypeQualifiers(QualType T, unsigned CVRQualifiers) { 1560 if (CVRQualifiers && !T->isFunctionType() && !T->isReferenceType()) 1561 return T.getWithAdditionalQualifiers(CVRQualifiers); 1562 1563 return T; 1564} 1565 1566template<typename Derived> 1567QualType TreeTransform<Derived>::TransformExtQualType(const ExtQualType *T) { 1568 // FIXME: Implement 1569 return QualType(T, 0); 1570} 1571 1572template<typename Derived> 1573QualType TreeTransform<Derived>::TransformBuiltinType(const BuiltinType *T) { 1574 // Nothing to do 1575 return QualType(T, 0); 1576} 1577 1578template<typename Derived> 1579QualType TreeTransform<Derived>::TransformFixedWidthIntType( 1580 const FixedWidthIntType *T) { 1581 // FIXME: Implement 1582 return QualType(T, 0); 1583} 1584 1585template<typename Derived> 1586QualType TreeTransform<Derived>::TransformComplexType(const ComplexType *T) { 1587 // FIXME: Implement 1588 return QualType(T, 0); 1589} 1590 1591template<typename Derived> 1592QualType TreeTransform<Derived>::TransformPointerType(const PointerType *T) { 1593 QualType PointeeType = getDerived().TransformType(T->getPointeeType()); 1594 if (PointeeType.isNull()) 1595 return QualType(); 1596 1597 if (!getDerived().AlwaysRebuild() && 1598 PointeeType == T->getPointeeType()) 1599 return QualType(T, 0); 1600 1601 return getDerived().RebuildPointerType(PointeeType); 1602} 1603 1604template<typename Derived> 1605QualType 1606TreeTransform<Derived>::TransformBlockPointerType(const BlockPointerType *T) { 1607 QualType PointeeType = getDerived().TransformType(T->getPointeeType()); 1608 if (PointeeType.isNull()) 1609 return QualType(); 1610 1611 if (!getDerived().AlwaysRebuild() && 1612 PointeeType == T->getPointeeType()) 1613 return QualType(T, 0); 1614 1615 return getDerived().RebuildBlockPointerType(PointeeType); 1616} 1617 1618template<typename Derived> 1619QualType 1620TreeTransform<Derived>::TransformLValueReferenceType( 1621 const LValueReferenceType *T) { 1622 QualType PointeeType = getDerived().TransformType(T->getPointeeType()); 1623 if (PointeeType.isNull()) 1624 return QualType(); 1625 1626 if (!getDerived().AlwaysRebuild() && 1627 PointeeType == T->getPointeeType()) 1628 return QualType(T, 0); 1629 1630 return getDerived().RebuildLValueReferenceType(PointeeType); 1631} 1632 1633template<typename Derived> 1634QualType 1635TreeTransform<Derived>::TransformRValueReferenceType( 1636 const RValueReferenceType *T) { 1637 QualType PointeeType = getDerived().TransformType(T->getPointeeType()); 1638 if (PointeeType.isNull()) 1639 return QualType(); 1640 1641 if (!getDerived().AlwaysRebuild() && 1642 PointeeType == T->getPointeeType()) 1643 return QualType(T, 0); 1644 1645 return getDerived().RebuildRValueReferenceType(PointeeType); 1646} 1647 1648template<typename Derived> 1649QualType 1650TreeTransform<Derived>::TransformMemberPointerType(const MemberPointerType *T) { 1651 QualType PointeeType = getDerived().TransformType(T->getPointeeType()); 1652 if (PointeeType.isNull()) 1653 return QualType(); 1654 1655 QualType ClassType = getDerived().TransformType(QualType(T->getClass(), 0)); 1656 if (ClassType.isNull()) 1657 return QualType(); 1658 1659 if (!getDerived().AlwaysRebuild() && 1660 PointeeType == T->getPointeeType() && 1661 ClassType == QualType(T->getClass(), 0)) 1662 return QualType(T, 0); 1663 1664 return getDerived().RebuildMemberPointerType(PointeeType, ClassType); 1665} 1666 1667template<typename Derived> 1668QualType 1669TreeTransform<Derived>::TransformConstantArrayType(const ConstantArrayType *T) { 1670 QualType ElementType = getDerived().TransformType(T->getElementType()); 1671 if (ElementType.isNull()) 1672 return QualType(); 1673 1674 if (!getDerived().AlwaysRebuild() && 1675 ElementType == T->getElementType()) 1676 return QualType(T, 0); 1677 1678 return getDerived().RebuildConstantArrayType(ElementType, 1679 T->getSizeModifier(), 1680 T->getSize(), 1681 T->getIndexTypeQualifier()); 1682} 1683 1684template<typename Derived> 1685QualType 1686TreeTransform<Derived>::TransformConstantArrayWithExprType( 1687 const ConstantArrayWithExprType *T) { 1688 QualType ElementType = getDerived().TransformType(T->getElementType()); 1689 if (ElementType.isNull()) 1690 return QualType(); 1691 1692 // Array bounds are not potentially evaluated contexts 1693 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 1694 1695 Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); 1696 if (Size.isInvalid()) 1697 return QualType(); 1698 1699 if (!getDerived().AlwaysRebuild() && 1700 ElementType == T->getElementType() && 1701 Size.get() == T->getSizeExpr()) 1702 return QualType(T, 0); 1703 1704 return getDerived().RebuildConstantArrayWithExprType(ElementType, 1705 T->getSizeModifier(), 1706 T->getSize(), 1707 Size.takeAs<Expr>(), 1708 T->getIndexTypeQualifier(), 1709 T->getBracketsRange()); 1710} 1711 1712template<typename Derived> 1713QualType 1714TreeTransform<Derived>::TransformConstantArrayWithoutExprType( 1715 const ConstantArrayWithoutExprType *T) { 1716 QualType ElementType = getDerived().TransformType(T->getElementType()); 1717 if (ElementType.isNull()) 1718 return QualType(); 1719 1720 if (!getDerived().AlwaysRebuild() && 1721 ElementType == T->getElementType()) 1722 return QualType(T, 0); 1723 1724 return getDerived().RebuildConstantArrayWithoutExprType(ElementType, 1725 T->getSizeModifier(), 1726 T->getSize(), 1727 T->getIndexTypeQualifier()); 1728} 1729 1730template<typename Derived> 1731QualType TreeTransform<Derived>::TransformIncompleteArrayType( 1732 const IncompleteArrayType *T) { 1733 QualType ElementType = getDerived().TransformType(T->getElementType()); 1734 if (ElementType.isNull()) 1735 return QualType(); 1736 1737 if (!getDerived().AlwaysRebuild() && 1738 ElementType == T->getElementType()) 1739 return QualType(T, 0); 1740 1741 return getDerived().RebuildIncompleteArrayType(ElementType, 1742 T->getSizeModifier(), 1743 T->getIndexTypeQualifier()); 1744} 1745 1746template<typename Derived> 1747QualType TreeTransform<Derived>::TransformVariableArrayType( 1748 const VariableArrayType *T) { 1749 QualType ElementType = getDerived().TransformType(T->getElementType()); 1750 if (ElementType.isNull()) 1751 return QualType(); 1752 1753 // Array bounds are not potentially evaluated contexts 1754 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 1755 1756 Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); 1757 if (Size.isInvalid()) 1758 return QualType(); 1759 1760 if (!getDerived().AlwaysRebuild() && 1761 ElementType == T->getElementType() && 1762 Size.get() == T->getSizeExpr()) { 1763 Size.take(); 1764 return QualType(T, 0); 1765 } 1766 1767 return getDerived().RebuildVariableArrayType(ElementType, 1768 T->getSizeModifier(), 1769 move(Size), 1770 T->getIndexTypeQualifier(), 1771 T->getBracketsRange()); 1772} 1773 1774template<typename Derived> 1775QualType TreeTransform<Derived>::TransformDependentSizedArrayType( 1776 const DependentSizedArrayType *T) { 1777 QualType ElementType = getDerived().TransformType(T->getElementType()); 1778 if (ElementType.isNull()) 1779 return QualType(); 1780 1781 // Array bounds are not potentially evaluated contexts 1782 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 1783 1784 Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); 1785 if (Size.isInvalid()) 1786 return QualType(); 1787 1788 if (!getDerived().AlwaysRebuild() && 1789 ElementType == T->getElementType() && 1790 Size.get() == T->getSizeExpr()) { 1791 Size.take(); 1792 return QualType(T, 0); 1793 } 1794 1795 return getDerived().RebuildDependentSizedArrayType(ElementType, 1796 T->getSizeModifier(), 1797 move(Size), 1798 T->getIndexTypeQualifier(), 1799 T->getBracketsRange()); 1800} 1801 1802template<typename Derived> 1803QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType( 1804 const DependentSizedExtVectorType *T) { 1805 QualType ElementType = getDerived().TransformType(T->getElementType()); 1806 if (ElementType.isNull()) 1807 return QualType(); 1808 1809 // Vector sizes are not potentially evaluated contexts 1810 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 1811 1812 Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); 1813 if (Size.isInvalid()) 1814 return QualType(); 1815 1816 if (!getDerived().AlwaysRebuild() && 1817 ElementType == T->getElementType() && 1818 Size.get() == T->getSizeExpr()) { 1819 Size.take(); 1820 return QualType(T, 0); 1821 } 1822 1823 return getDerived().RebuildDependentSizedExtVectorType(ElementType, 1824 move(Size), 1825 T->getAttributeLoc()); 1826} 1827 1828template<typename Derived> 1829QualType TreeTransform<Derived>::TransformVectorType(const VectorType *T) { 1830 QualType ElementType = getDerived().TransformType(T->getElementType()); 1831 if (ElementType.isNull()) 1832 return QualType(); 1833 1834 if (!getDerived().AlwaysRebuild() && 1835 ElementType == T->getElementType()) 1836 return QualType(T, 0); 1837 1838 return getDerived().RebuildVectorType(ElementType, T->getNumElements()); 1839} 1840 1841template<typename Derived> 1842QualType 1843TreeTransform<Derived>::TransformExtVectorType(const ExtVectorType *T) { 1844 QualType ElementType = getDerived().TransformType(T->getElementType()); 1845 if (ElementType.isNull()) 1846 return QualType(); 1847 1848 if (!getDerived().AlwaysRebuild() && 1849 ElementType == T->getElementType()) 1850 return QualType(T, 0); 1851 1852 return getDerived().RebuildExtVectorType(ElementType, T->getNumElements(), 1853 /*FIXME*/SourceLocation()); 1854} 1855 1856template<typename Derived> 1857QualType TreeTransform<Derived>::TransformFunctionProtoType( 1858 const FunctionProtoType *T) { 1859 QualType ResultType = getDerived().TransformType(T->getResultType()); 1860 if (ResultType.isNull()) 1861 return QualType(); 1862 1863 llvm::SmallVector<QualType, 4> ParamTypes; 1864 for (FunctionProtoType::arg_type_iterator Param = T->arg_type_begin(), 1865 ParamEnd = T->arg_type_end(); 1866 Param != ParamEnd; ++Param) { 1867 QualType P = getDerived().TransformType(*Param); 1868 if (P.isNull()) 1869 return QualType(); 1870 1871 ParamTypes.push_back(P); 1872 } 1873 1874 if (!getDerived().AlwaysRebuild() && 1875 ResultType == T->getResultType() && 1876 std::equal(T->arg_type_begin(), T->arg_type_end(), ParamTypes.begin())) 1877 return QualType(T, 0); 1878 1879 return getDerived().RebuildFunctionProtoType(ResultType, ParamTypes.data(), 1880 ParamTypes.size(), T->isVariadic(), 1881 T->getTypeQuals()); 1882} 1883 1884template<typename Derived> 1885QualType TreeTransform<Derived>::TransformFunctionNoProtoType( 1886 const FunctionNoProtoType *T) { 1887 // FIXME: Implement 1888 return QualType(T, 0); 1889} 1890 1891template<typename Derived> 1892QualType TreeTransform<Derived>::TransformTypedefType(const TypedefType *T) { 1893 TypedefDecl *Typedef 1894 = cast_or_null<TypedefDecl>(getDerived().TransformDecl(T->getDecl())); 1895 if (!Typedef) 1896 return QualType(); 1897 1898 if (!getDerived().AlwaysRebuild() && 1899 Typedef == T->getDecl()) 1900 return QualType(T, 0); 1901 1902 return getDerived().RebuildTypedefType(Typedef); 1903} 1904 1905template<typename Derived> 1906QualType TreeTransform<Derived>::TransformTypeOfExprType( 1907 const TypeOfExprType *T) { 1908 // typeof expressions are not potentially evaluated contexts 1909 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 1910 1911 Sema::OwningExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); 1912 if (E.isInvalid()) 1913 return QualType(); 1914 1915 if (!getDerived().AlwaysRebuild() && 1916 E.get() == T->getUnderlyingExpr()) { 1917 E.take(); 1918 return QualType(T, 0); 1919 } 1920 1921 return getDerived().RebuildTypeOfExprType(move(E)); 1922} 1923 1924template<typename Derived> 1925QualType TreeTransform<Derived>::TransformTypeOfType(const TypeOfType *T) { 1926 QualType Underlying = getDerived().TransformType(T->getUnderlyingType()); 1927 if (Underlying.isNull()) 1928 return QualType(); 1929 1930 if (!getDerived().AlwaysRebuild() && 1931 Underlying == T->getUnderlyingType()) 1932 return QualType(T, 0); 1933 1934 return getDerived().RebuildTypeOfType(Underlying); 1935} 1936 1937template<typename Derived> 1938QualType TreeTransform<Derived>::TransformDecltypeType(const DecltypeType *T) { 1939 // decltype expressions are not potentially evaluated contexts 1940 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 1941 1942 Sema::OwningExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); 1943 if (E.isInvalid()) 1944 return QualType(); 1945 1946 if (!getDerived().AlwaysRebuild() && 1947 E.get() == T->getUnderlyingExpr()) { 1948 E.take(); 1949 return QualType(T, 0); 1950 } 1951 1952 return getDerived().RebuildDecltypeType(move(E)); 1953} 1954 1955template<typename Derived> 1956QualType TreeTransform<Derived>::TransformRecordType(const RecordType *T) { 1957 RecordDecl *Record 1958 = cast_or_null<RecordDecl>(getDerived().TransformDecl(T->getDecl())); 1959 if (!Record) 1960 return QualType(); 1961 1962 if (!getDerived().AlwaysRebuild() && 1963 Record == T->getDecl()) 1964 return QualType(T, 0); 1965 1966 return getDerived().RebuildRecordType(Record); 1967} 1968 1969template<typename Derived> 1970QualType TreeTransform<Derived>::TransformEnumType(const EnumType *T) { 1971 EnumDecl *Enum 1972 = cast_or_null<EnumDecl>(getDerived().TransformDecl(T->getDecl())); 1973 if (!Enum) 1974 return QualType(); 1975 1976 if (!getDerived().AlwaysRebuild() && 1977 Enum == T->getDecl()) 1978 return QualType(T, 0); 1979 1980 return getDerived().RebuildEnumType(Enum); 1981} 1982 1983template<typename Derived> 1984QualType TreeTransform<Derived>::TransformTemplateTypeParmType( 1985 const TemplateTypeParmType *T) { 1986 // Nothing to do 1987 return QualType(T, 0); 1988} 1989 1990template<typename Derived> 1991QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 1992 const TemplateSpecializationType *T) { 1993 TemplateName Template 1994 = getDerived().TransformTemplateName(T->getTemplateName()); 1995 if (Template.isNull()) 1996 return QualType(); 1997 1998 llvm::SmallVector<TemplateArgument, 4> NewTemplateArgs; 1999 NewTemplateArgs.reserve(T->getNumArgs()); 2000 for (TemplateSpecializationType::iterator Arg = T->begin(), ArgEnd = T->end(); 2001 Arg != ArgEnd; ++Arg) { 2002 TemplateArgument NewArg = getDerived().TransformTemplateArgument(*Arg); 2003 if (NewArg.isNull()) 2004 return QualType(); 2005 2006 NewTemplateArgs.push_back(NewArg); 2007 } 2008 2009 // FIXME: early abort if all of the template arguments and such are the 2010 // same. 2011 2012 // FIXME: We're missing the locations of the template name, '<', and '>'. 2013 return getDerived().RebuildTemplateSpecializationType(Template, 2014 NewTemplateArgs.data(), 2015 NewTemplateArgs.size()); 2016} 2017 2018template<typename Derived> 2019QualType TreeTransform<Derived>::TransformQualifiedNameType( 2020 const QualifiedNameType *T) { 2021 NestedNameSpecifier *NNS 2022 = getDerived().TransformNestedNameSpecifier(T->getQualifier(), 2023 SourceRange()); 2024 if (!NNS) 2025 return QualType(); 2026 2027 QualType Named = getDerived().TransformType(T->getNamedType()); 2028 if (Named.isNull()) 2029 return QualType(); 2030 2031 if (!getDerived().AlwaysRebuild() && 2032 NNS == T->getQualifier() && 2033 Named == T->getNamedType()) 2034 return QualType(T, 0); 2035 2036 return getDerived().RebuildQualifiedNameType(NNS, Named); 2037} 2038 2039template<typename Derived> 2040QualType TreeTransform<Derived>::TransformTypenameType(const TypenameType *T) { 2041 NestedNameSpecifier *NNS 2042 = getDerived().TransformNestedNameSpecifier(T->getQualifier(), 2043 SourceRange(/*FIXME:*/getDerived().getBaseLocation())); 2044 if (!NNS) 2045 return QualType(); 2046 2047 if (const TemplateSpecializationType *TemplateId = T->getTemplateId()) { 2048 QualType NewTemplateId 2049 = getDerived().TransformType(QualType(TemplateId, 0)); 2050 if (NewTemplateId.isNull()) 2051 return QualType(); 2052 2053 if (!getDerived().AlwaysRebuild() && 2054 NNS == T->getQualifier() && 2055 NewTemplateId == QualType(TemplateId, 0)) 2056 return QualType(T, 0); 2057 2058 return getDerived().RebuildTypenameType(NNS, NewTemplateId); 2059 } 2060 2061 return getDerived().RebuildTypenameType(NNS, T->getIdentifier()); 2062} 2063 2064template<typename Derived> 2065QualType TreeTransform<Derived>::TransformObjCInterfaceType( 2066 const ObjCInterfaceType *T) { 2067 // FIXME: Implement 2068 return QualType(T, 0); 2069} 2070 2071template<typename Derived> 2072QualType TreeTransform<Derived>::TransformObjCObjectPointerType( 2073 const ObjCObjectPointerType *T) { 2074 // FIXME: Implement 2075 return QualType(T, 0); 2076} 2077 2078//===----------------------------------------------------------------------===// 2079// Expression transformation 2080//===----------------------------------------------------------------------===// 2081template<typename Derived> 2082Sema::OwningExprResult 2083TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) { 2084 return SemaRef.Owned(E->Retain()); 2085} 2086 2087template<typename Derived> 2088Sema::OwningExprResult 2089TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) { 2090 NamedDecl *ND 2091 = dyn_cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getDecl())); 2092 if (!ND) 2093 return SemaRef.ExprError(); 2094 2095 if (!getDerived().AlwaysRebuild() && ND == E->getDecl()) 2096 return SemaRef.Owned(E->Retain()); 2097 2098 return getDerived().RebuildDeclRefExpr(ND, E->getLocation()); 2099} 2100 2101template<typename Derived> 2102Sema::OwningExprResult 2103TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) { 2104 return SemaRef.Owned(E->Retain()); 2105} 2106 2107template<typename Derived> 2108Sema::OwningExprResult 2109TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) { 2110 return SemaRef.Owned(E->Retain()); 2111} 2112 2113template<typename Derived> 2114Sema::OwningExprResult 2115TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) { 2116 return SemaRef.Owned(E->Retain()); 2117} 2118 2119template<typename Derived> 2120Sema::OwningExprResult 2121TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) { 2122 return SemaRef.Owned(E->Retain()); 2123} 2124 2125template<typename Derived> 2126Sema::OwningExprResult 2127TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) { 2128 return SemaRef.Owned(E->Retain()); 2129} 2130 2131template<typename Derived> 2132Sema::OwningExprResult 2133TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) { 2134 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 2135 if (SubExpr.isInvalid()) 2136 return SemaRef.ExprError(); 2137 2138 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 2139 return SemaRef.Owned(E->Retain()); 2140 2141 return getDerived().RebuildParenExpr(move(SubExpr), E->getLParen(), 2142 E->getRParen()); 2143} 2144 2145template<typename Derived> 2146Sema::OwningExprResult 2147TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) { 2148 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 2149 if (SubExpr.isInvalid()) 2150 return SemaRef.ExprError(); 2151 2152 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 2153 return SemaRef.Owned(E->Retain()); 2154 2155 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(), 2156 E->getOpcode(), 2157 move(SubExpr)); 2158} 2159 2160template<typename Derived> 2161Sema::OwningExprResult 2162TreeTransform<Derived>::TransformSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { 2163 if (E->isArgumentType()) { 2164 QualType T = getDerived().TransformType(E->getArgumentType()); 2165 if (T.isNull()) 2166 return SemaRef.ExprError(); 2167 2168 if (!getDerived().AlwaysRebuild() && T == E->getArgumentType()) 2169 return SemaRef.Owned(E->Retain()); 2170 2171 return getDerived().RebuildSizeOfAlignOf(T, E->getOperatorLoc(), 2172 E->isSizeOf(), 2173 E->getSourceRange()); 2174 } 2175 2176 Sema::OwningExprResult SubExpr(SemaRef); 2177 { 2178 // C++0x [expr.sizeof]p1: 2179 // The operand is either an expression, which is an unevaluated operand 2180 // [...] 2181 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2182 2183 SubExpr = getDerived().TransformExpr(E->getArgumentExpr()); 2184 if (SubExpr.isInvalid()) 2185 return SemaRef.ExprError(); 2186 2187 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr()) 2188 return SemaRef.Owned(E->Retain()); 2189 } 2190 2191 return getDerived().RebuildSizeOfAlignOf(move(SubExpr), E->getOperatorLoc(), 2192 E->isSizeOf(), 2193 E->getSourceRange()); 2194} 2195 2196template<typename Derived> 2197Sema::OwningExprResult 2198TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) { 2199 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 2200 if (LHS.isInvalid()) 2201 return SemaRef.ExprError(); 2202 2203 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 2204 if (RHS.isInvalid()) 2205 return SemaRef.ExprError(); 2206 2207 2208 if (!getDerived().AlwaysRebuild() && 2209 LHS.get() == E->getLHS() && 2210 RHS.get() == E->getRHS()) 2211 return SemaRef.Owned(E->Retain()); 2212 2213 return getDerived().RebuildArraySubscriptExpr(move(LHS), 2214 /*FIXME:*/E->getLHS()->getLocStart(), 2215 move(RHS), 2216 E->getRBracketLoc()); 2217} 2218 2219template<typename Derived> 2220Sema::OwningExprResult 2221TreeTransform<Derived>::TransformCallExpr(CallExpr *E) { 2222 // Transform the callee. 2223 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee()); 2224 if (Callee.isInvalid()) 2225 return SemaRef.ExprError(); 2226 2227 // Transform arguments. 2228 bool ArgChanged = false; 2229 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 2230 llvm::SmallVector<SourceLocation, 4> FakeCommaLocs; 2231 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) { 2232 OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I)); 2233 if (Arg.isInvalid()) 2234 return SemaRef.ExprError(); 2235 2236 // FIXME: Wrong source location information for the ','. 2237 FakeCommaLocs.push_back( 2238 SemaRef.PP.getLocForEndOfToken(E->getArg(I)->getSourceRange().getEnd())); 2239 2240 ArgChanged = ArgChanged || Arg.get() != E->getArg(I); 2241 Args.push_back(Arg.takeAs<Expr>()); 2242 } 2243 2244 if (!getDerived().AlwaysRebuild() && 2245 Callee.get() == E->getCallee() && 2246 !ArgChanged) 2247 return SemaRef.Owned(E->Retain()); 2248 2249 // FIXME: Wrong source location information for the '('. 2250 SourceLocation FakeLParenLoc 2251 = ((Expr *)Callee.get())->getSourceRange().getBegin(); 2252 return getDerived().RebuildCallExpr(move(Callee), FakeLParenLoc, 2253 move_arg(Args), 2254 FakeCommaLocs.data(), 2255 E->getRParenLoc()); 2256} 2257 2258template<typename Derived> 2259Sema::OwningExprResult 2260TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) { 2261 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 2262 if (Base.isInvalid()) 2263 return SemaRef.ExprError(); 2264 2265 NamedDecl *Member 2266 = cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getMemberDecl())); 2267 if (!Member) 2268 return SemaRef.ExprError(); 2269 2270 if (!getDerived().AlwaysRebuild() && 2271 Base.get() == E->getBase() && 2272 Member == E->getMemberDecl()) 2273 return SemaRef.Owned(E->Retain()); 2274 2275 // FIXME: Bogus source location for the operator 2276 SourceLocation FakeOperatorLoc 2277 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd()); 2278 2279 return getDerived().RebuildMemberExpr(move(Base), FakeOperatorLoc, 2280 E->isArrow(), 2281 E->getMemberLoc(), 2282 Member); 2283} 2284 2285template<typename Derived> 2286Sema::OwningExprResult 2287TreeTransform<Derived>::TransformCastExpr(CastExpr *E) { 2288 assert(false && "Cannot transform abstract class"); 2289 return SemaRef.Owned(E->Retain()); 2290} 2291 2292template<typename Derived> 2293Sema::OwningExprResult 2294TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) { 2295 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 2296 if (LHS.isInvalid()) 2297 return SemaRef.ExprError(); 2298 2299 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 2300 if (RHS.isInvalid()) 2301 return SemaRef.ExprError(); 2302 2303 if (!getDerived().AlwaysRebuild() && 2304 LHS.get() == E->getLHS() && 2305 RHS.get() == E->getRHS()) 2306 return SemaRef.Owned(E->Retain()); 2307 2308 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(), 2309 move(LHS), move(RHS)); 2310} 2311 2312template<typename Derived> 2313Sema::OwningExprResult 2314TreeTransform<Derived>::TransformCompoundAssignOperator( 2315 CompoundAssignOperator *E) { 2316 return getDerived().TransformBinaryOperator(E); 2317} 2318 2319template<typename Derived> 2320Sema::OwningExprResult 2321TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) { 2322 OwningExprResult Cond = getDerived().TransformExpr(E->getCond()); 2323 if (Cond.isInvalid()) 2324 return SemaRef.ExprError(); 2325 2326 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 2327 if (LHS.isInvalid()) 2328 return SemaRef.ExprError(); 2329 2330 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 2331 if (RHS.isInvalid()) 2332 return SemaRef.ExprError(); 2333 2334 if (!getDerived().AlwaysRebuild() && 2335 Cond.get() == E->getCond() && 2336 LHS.get() == E->getLHS() && 2337 RHS.get() == E->getRHS()) 2338 return SemaRef.Owned(E->Retain()); 2339 2340 // FIXM: ? and : locations are broken. 2341 SourceLocation FakeQuestionLoc = E->getCond()->getLocEnd(); 2342 SourceLocation FakeColonLoc = E->getFalseExpr()->getLocStart(); 2343 return getDerived().RebuildConditionalOperator(move(Cond), 2344 FakeQuestionLoc, 2345 move(LHS), 2346 FakeColonLoc, 2347 move(RHS)); 2348} 2349 2350template<typename Derived> 2351Sema::OwningExprResult 2352TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) { 2353 QualType T = getDerived().TransformType(E->getType()); 2354 if (T.isNull()) 2355 return SemaRef.ExprError(); 2356 2357 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 2358 if (SubExpr.isInvalid()) 2359 return SemaRef.ExprError(); 2360 2361 if (!getDerived().AlwaysRebuild() && 2362 T == E->getType() && 2363 SubExpr.get() == E->getSubExpr()) 2364 return SemaRef.Owned(E->Retain()); 2365 2366 return getDerived().RebuildImplicitCastExpr(T, E->getCastKind(), 2367 move(SubExpr), 2368 E->isLvalueCast()); 2369} 2370 2371template<typename Derived> 2372Sema::OwningExprResult 2373TreeTransform<Derived>::TransformExplicitCastExpr(ExplicitCastExpr *E) { 2374 assert(false && "Cannot transform abstract class"); 2375 return SemaRef.Owned(E->Retain()); 2376} 2377 2378template<typename Derived> 2379Sema::OwningExprResult 2380TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) { 2381 QualType T; 2382 { 2383 // FIXME: Source location isn't quite accurate. 2384 SourceLocation TypeStartLoc 2385 = SemaRef.PP.getLocForEndOfToken(E->getLParenLoc()); 2386 TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName()); 2387 2388 T = getDerived().TransformType(E->getTypeAsWritten()); 2389 if (T.isNull()) 2390 return SemaRef.ExprError(); 2391 } 2392 2393 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 2394 if (SubExpr.isInvalid()) 2395 return SemaRef.ExprError(); 2396 2397 if (!getDerived().AlwaysRebuild() && 2398 T == E->getTypeAsWritten() && 2399 SubExpr.get() == E->getSubExpr()) 2400 return SemaRef.Owned(E->Retain()); 2401 2402 return getDerived().RebuildCStyleCaseExpr(E->getLParenLoc(), T, 2403 E->getRParenLoc(), 2404 move(SubExpr)); 2405} 2406 2407template<typename Derived> 2408Sema::OwningExprResult 2409TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) { 2410 QualType T; 2411 { 2412 // FIXME: Source location isn't quite accurate. 2413 SourceLocation FakeTypeLoc 2414 = SemaRef.PP.getLocForEndOfToken(E->getLParenLoc()); 2415 TemporaryBase Rebase(*this, FakeTypeLoc, DeclarationName()); 2416 2417 T = getDerived().TransformType(E->getType()); 2418 if (T.isNull()) 2419 return SemaRef.ExprError(); 2420 } 2421 2422 OwningExprResult Init = getDerived().TransformExpr(E->getInitializer()); 2423 if (Init.isInvalid()) 2424 return SemaRef.ExprError(); 2425 2426 if (!getDerived().AlwaysRebuild() && 2427 T == E->getType() && 2428 Init.get() == E->getInitializer()) 2429 return SemaRef.Owned(E->Retain()); 2430 2431 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), T, 2432 /*FIXME:*/E->getInitializer()->getLocEnd(), 2433 move(Init)); 2434} 2435 2436template<typename Derived> 2437Sema::OwningExprResult 2438TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) { 2439 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 2440 if (Base.isInvalid()) 2441 return SemaRef.ExprError(); 2442 2443 if (!getDerived().AlwaysRebuild() && 2444 Base.get() == E->getBase()) 2445 return SemaRef.Owned(E->Retain()); 2446 2447 // FIXME: Bad source location 2448 SourceLocation FakeOperatorLoc 2449 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getLocEnd()); 2450 return getDerived().RebuildExtVectorElementExpr(move(Base), FakeOperatorLoc, 2451 E->getAccessorLoc(), 2452 E->getAccessor()); 2453} 2454 2455template<typename Derived> 2456Sema::OwningExprResult 2457TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) { 2458 bool InitChanged = false; 2459 2460 ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef); 2461 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) { 2462 OwningExprResult Init = getDerived().TransformExpr(E->getInit(I)); 2463 if (Init.isInvalid()) 2464 return SemaRef.ExprError(); 2465 2466 InitChanged = InitChanged || Init.get() != E->getInit(I); 2467 Inits.push_back(Init.takeAs<Expr>()); 2468 } 2469 2470 if (!getDerived().AlwaysRebuild() && !InitChanged) 2471 return SemaRef.Owned(E->Retain()); 2472 2473 return getDerived().RebuildInitList(E->getLBraceLoc(), move_arg(Inits), 2474 E->getRBraceLoc()); 2475} 2476 2477template<typename Derived> 2478Sema::OwningExprResult 2479TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { 2480 Designation Desig; 2481 2482 // Instantiate the initializer value 2483 OwningExprResult Init = getDerived().TransformExpr(E->getInit()); 2484 if (Init.isInvalid()) 2485 return SemaRef.ExprError(); 2486 2487 // Instantiate the designators. 2488 ASTOwningVector<&ActionBase::DeleteExpr, 4> ArrayExprs(SemaRef); 2489 bool ExprChanged = false; 2490 for (DesignatedInitExpr::designators_iterator D = E->designators_begin(), 2491 DEnd = E->designators_end(); 2492 D != DEnd; ++D) { 2493 if (D->isFieldDesignator()) { 2494 Desig.AddDesignator(Designator::getField(D->getFieldName(), 2495 D->getDotLoc(), 2496 D->getFieldLoc())); 2497 continue; 2498 } 2499 2500 if (D->isArrayDesignator()) { 2501 OwningExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D)); 2502 if (Index.isInvalid()) 2503 return SemaRef.ExprError(); 2504 2505 Desig.AddDesignator(Designator::getArray(Index.get(), 2506 D->getLBracketLoc())); 2507 2508 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D); 2509 ArrayExprs.push_back(Index.release()); 2510 continue; 2511 } 2512 2513 assert(D->isArrayRangeDesignator() && "New kind of designator?"); 2514 OwningExprResult Start 2515 = getDerived().TransformExpr(E->getArrayRangeStart(*D)); 2516 if (Start.isInvalid()) 2517 return SemaRef.ExprError(); 2518 2519 OwningExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D)); 2520 if (End.isInvalid()) 2521 return SemaRef.ExprError(); 2522 2523 Desig.AddDesignator(Designator::getArrayRange(Start.get(), 2524 End.get(), 2525 D->getLBracketLoc(), 2526 D->getEllipsisLoc())); 2527 2528 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) || 2529 End.get() != E->getArrayRangeEnd(*D); 2530 2531 ArrayExprs.push_back(Start.release()); 2532 ArrayExprs.push_back(End.release()); 2533 } 2534 2535 if (!getDerived().AlwaysRebuild() && 2536 Init.get() == E->getInit() && 2537 !ExprChanged) 2538 return SemaRef.Owned(E->Retain()); 2539 2540 return getDerived().RebuildDesignatedInitExpr(Desig, move_arg(ArrayExprs), 2541 E->getEqualOrColonLoc(), 2542 E->usesGNUSyntax(), move(Init)); 2543} 2544 2545template<typename Derived> 2546Sema::OwningExprResult 2547TreeTransform<Derived>::TransformImplicitValueInitExpr( 2548 ImplicitValueInitExpr *E) { 2549 QualType T = getDerived().TransformType(E->getType()); 2550 if (T.isNull()) 2551 return SemaRef.ExprError(); 2552 2553 if (!getDerived().AlwaysRebuild() && 2554 T == E->getType()) 2555 return SemaRef.Owned(E->Retain()); 2556 2557 return getDerived().RebuildImplicitValueInitExpr(T); 2558} 2559 2560template<typename Derived> 2561Sema::OwningExprResult 2562TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) { 2563 // FIXME: Do we want the type as written? 2564 QualType T; 2565 2566 { 2567 // FIXME: Source location isn't quite accurate. 2568 TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName()); 2569 T = getDerived().TransformType(E->getType()); 2570 if (T.isNull()) 2571 return SemaRef.ExprError(); 2572 } 2573 2574 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 2575 if (SubExpr.isInvalid()) 2576 return SemaRef.ExprError(); 2577 2578 if (!getDerived().AlwaysRebuild() && 2579 T == E->getType() && 2580 SubExpr.get() == E->getSubExpr()) 2581 return SemaRef.Owned(E->Retain()); 2582 2583 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), move(SubExpr), 2584 T, E->getRParenLoc()); 2585} 2586 2587template<typename Derived> 2588Sema::OwningExprResult 2589TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) { 2590 bool ArgumentChanged = false; 2591 ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef); 2592 for (unsigned I = 0, N = E->getNumExprs(); I != N; ++I) { 2593 OwningExprResult Init = getDerived().TransformExpr(E->getExpr(I)); 2594 if (Init.isInvalid()) 2595 return SemaRef.ExprError(); 2596 2597 ArgumentChanged = ArgumentChanged || Init.get() != E->getExpr(I); 2598 Inits.push_back(Init.takeAs<Expr>()); 2599 } 2600 2601 return getDerived().RebuildParenListExpr(E->getLParenLoc(), 2602 move_arg(Inits), 2603 E->getRParenLoc()); 2604} 2605 2606/// \brief Transform an address-of-label expression. 2607/// 2608/// By default, the transformation of an address-of-label expression always 2609/// rebuilds the expression, so that the label identifier can be resolved to 2610/// the corresponding label statement by semantic analysis. 2611template<typename Derived> 2612Sema::OwningExprResult 2613TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) { 2614 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(), 2615 E->getLabel()); 2616} 2617 2618template<typename Derived> 2619Sema::OwningExprResult TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) { 2620 OwningStmtResult SubStmt 2621 = getDerived().TransformCompoundStmt(E->getSubStmt(), true); 2622 if (SubStmt.isInvalid()) 2623 return SemaRef.ExprError(); 2624 2625 if (!getDerived().AlwaysRebuild() && 2626 SubStmt.get() == E->getSubStmt()) 2627 return SemaRef.Owned(E->Retain()); 2628 2629 return getDerived().RebuildStmtExpr(E->getLParenLoc(), 2630 move(SubStmt), 2631 E->getRParenLoc()); 2632} 2633 2634template<typename Derived> 2635Sema::OwningExprResult 2636TreeTransform<Derived>::TransformTypesCompatibleExpr(TypesCompatibleExpr *E) { 2637 QualType T1, T2; 2638 { 2639 // FIXME: Source location isn't quite accurate. 2640 TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName()); 2641 2642 T1 = getDerived().TransformType(E->getArgType1()); 2643 if (T1.isNull()) 2644 return SemaRef.ExprError(); 2645 2646 T2 = getDerived().TransformType(E->getArgType2()); 2647 if (T2.isNull()) 2648 return SemaRef.ExprError(); 2649 } 2650 2651 if (!getDerived().AlwaysRebuild() && 2652 T1 == E->getArgType1() && 2653 T2 == E->getArgType2()) 2654 return SemaRef.Owned(E->Retain()); 2655 2656 return getDerived().RebuildTypesCompatibleExpr(E->getBuiltinLoc(), 2657 T1, T2, E->getRParenLoc()); 2658} 2659 2660template<typename Derived> 2661Sema::OwningExprResult 2662TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) { 2663 OwningExprResult Cond = getDerived().TransformExpr(E->getCond()); 2664 if (Cond.isInvalid()) 2665 return SemaRef.ExprError(); 2666 2667 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 2668 if (LHS.isInvalid()) 2669 return SemaRef.ExprError(); 2670 2671 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 2672 if (RHS.isInvalid()) 2673 return SemaRef.ExprError(); 2674 2675 if (!getDerived().AlwaysRebuild() && 2676 Cond.get() == E->getCond() && 2677 LHS.get() == E->getLHS() && 2678 RHS.get() == E->getRHS()) 2679 return SemaRef.Owned(E->Retain()); 2680 2681 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(), 2682 move(Cond), move(LHS), move(RHS), 2683 E->getRParenLoc()); 2684} 2685 2686template<typename Derived> 2687Sema::OwningExprResult 2688TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) { 2689 return SemaRef.Owned(E->Retain()); 2690} 2691 2692template<typename Derived> 2693Sema::OwningExprResult 2694TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 2695 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee()); 2696 if (Callee.isInvalid()) 2697 return SemaRef.ExprError(); 2698 2699 OwningExprResult First = getDerived().TransformExpr(E->getArg(0)); 2700 if (First.isInvalid()) 2701 return SemaRef.ExprError(); 2702 2703 OwningExprResult Second(SemaRef); 2704 if (E->getNumArgs() == 2) { 2705 Second = getDerived().TransformExpr(E->getArg(1)); 2706 if (Second.isInvalid()) 2707 return SemaRef.ExprError(); 2708 } 2709 2710 if (!getDerived().AlwaysRebuild() && 2711 Callee.get() == E->getCallee() && 2712 First.get() == E->getArg(0) && 2713 (E->getNumArgs() != 2 || Second.get() == E->getArg(1))) 2714 return SemaRef.Owned(E->Retain()); 2715 2716 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(), 2717 E->getOperatorLoc(), 2718 move(Callee), 2719 move(First), 2720 move(Second)); 2721} 2722 2723template<typename Derived> 2724Sema::OwningExprResult 2725TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) { 2726 return getDerived().TransformCallExpr(E); 2727} 2728 2729template<typename Derived> 2730Sema::OwningExprResult 2731TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) { 2732 QualType ExplicitTy; 2733 { 2734 // FIXME: Source location isn't quite accurate. 2735 SourceLocation TypeStartLoc 2736 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc()); 2737 TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName()); 2738 2739 ExplicitTy = getDerived().TransformType(E->getTypeAsWritten()); 2740 if (ExplicitTy.isNull()) 2741 return SemaRef.ExprError(); 2742 } 2743 2744 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 2745 if (SubExpr.isInvalid()) 2746 return SemaRef.ExprError(); 2747 2748 if (!getDerived().AlwaysRebuild() && 2749 ExplicitTy == E->getTypeAsWritten() && 2750 SubExpr.get() == E->getSubExpr()) 2751 return SemaRef.Owned(E->Retain()); 2752 2753 // FIXME: Poor source location information here. 2754 SourceLocation FakeLAngleLoc 2755 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc()); 2756 SourceLocation FakeRAngleLoc = E->getSubExpr()->getSourceRange().getBegin(); 2757 SourceLocation FakeRParenLoc 2758 = SemaRef.PP.getLocForEndOfToken( 2759 E->getSubExpr()->getSourceRange().getEnd()); 2760 return getDerived().RebuildCXXNamedCastExpr(E->getOperatorLoc(), 2761 E->getStmtClass(), 2762 FakeLAngleLoc, 2763 ExplicitTy, 2764 FakeRAngleLoc, 2765 FakeRAngleLoc, 2766 move(SubExpr), 2767 FakeRParenLoc); 2768} 2769 2770template<typename Derived> 2771Sema::OwningExprResult 2772TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) { 2773 return getDerived().TransformCXXNamedCastExpr(E); 2774} 2775 2776template<typename Derived> 2777Sema::OwningExprResult 2778TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) { 2779 return getDerived().TransformCXXNamedCastExpr(E); 2780} 2781 2782template<typename Derived> 2783Sema::OwningExprResult 2784TreeTransform<Derived>::TransformCXXReinterpretCastExpr( 2785 CXXReinterpretCastExpr *E) { 2786 return getDerived().TransformCXXNamedCastExpr(E); 2787} 2788 2789template<typename Derived> 2790Sema::OwningExprResult 2791TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) { 2792 return getDerived().TransformCXXNamedCastExpr(E); 2793} 2794 2795template<typename Derived> 2796Sema::OwningExprResult 2797TreeTransform<Derived>::TransformCXXFunctionalCastExpr( 2798 CXXFunctionalCastExpr *E) { 2799 QualType ExplicitTy; 2800 { 2801 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 2802 2803 ExplicitTy = getDerived().TransformType(E->getTypeAsWritten()); 2804 if (ExplicitTy.isNull()) 2805 return SemaRef.ExprError(); 2806 } 2807 2808 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 2809 if (SubExpr.isInvalid()) 2810 return SemaRef.ExprError(); 2811 2812 if (!getDerived().AlwaysRebuild() && 2813 ExplicitTy == E->getTypeAsWritten() && 2814 SubExpr.get() == E->getSubExpr()) 2815 return SemaRef.Owned(E->Retain()); 2816 2817 // FIXME: The end of the type's source range is wrong 2818 return getDerived().RebuildCXXFunctionalCastExpr( 2819 /*FIXME:*/SourceRange(E->getTypeBeginLoc()), 2820 ExplicitTy, 2821 /*FIXME:*/E->getSubExpr()->getLocStart(), 2822 move(SubExpr), 2823 E->getRParenLoc()); 2824} 2825 2826template<typename Derived> 2827Sema::OwningExprResult 2828TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) { 2829 if (E->isTypeOperand()) { 2830 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 2831 2832 QualType T = getDerived().TransformType(E->getTypeOperand()); 2833 if (T.isNull()) 2834 return SemaRef.ExprError(); 2835 2836 if (!getDerived().AlwaysRebuild() && 2837 T == E->getTypeOperand()) 2838 return SemaRef.Owned(E->Retain()); 2839 2840 return getDerived().RebuildCXXTypeidExpr(E->getLocStart(), 2841 /*FIXME:*/E->getLocStart(), 2842 T, 2843 E->getLocEnd()); 2844 } 2845 2846 // We don't know whether the expression is potentially evaluated until 2847 // after we perform semantic analysis, so the expression is potentially 2848 // potentially evaluated. 2849 EnterExpressionEvaluationContext Unevaluated(SemaRef, 2850 Action::PotentiallyPotentiallyEvaluated); 2851 2852 OwningExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); 2853 if (SubExpr.isInvalid()) 2854 return SemaRef.ExprError(); 2855 2856 if (!getDerived().AlwaysRebuild() && 2857 SubExpr.get() == E->getExprOperand()) 2858 return SemaRef.Owned(E->Retain()); 2859 2860 return getDerived().RebuildCXXTypeidExpr(E->getLocStart(), 2861 /*FIXME:*/E->getLocStart(), 2862 move(SubExpr), 2863 E->getLocEnd()); 2864} 2865 2866template<typename Derived> 2867Sema::OwningExprResult 2868TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 2869 return SemaRef.Owned(E->Retain()); 2870} 2871 2872template<typename Derived> 2873Sema::OwningExprResult 2874TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr( 2875 CXXNullPtrLiteralExpr *E) { 2876 return SemaRef.Owned(E->Retain()); 2877} 2878 2879template<typename Derived> 2880Sema::OwningExprResult 2881TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) { 2882 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 2883 2884 QualType T = getDerived().TransformType(E->getType()); 2885 if (T.isNull()) 2886 return SemaRef.ExprError(); 2887 2888 if (!getDerived().AlwaysRebuild() && 2889 T == E->getType()) 2890 return SemaRef.Owned(E->Retain()); 2891 2892 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T); 2893} 2894 2895template<typename Derived> 2896Sema::OwningExprResult 2897TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) { 2898 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 2899 if (SubExpr.isInvalid()) 2900 return SemaRef.ExprError(); 2901 2902 if (!getDerived().AlwaysRebuild() && 2903 SubExpr.get() == E->getSubExpr()) 2904 return SemaRef.Owned(E->Retain()); 2905 2906 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), move(SubExpr)); 2907} 2908 2909template<typename Derived> 2910Sema::OwningExprResult 2911TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 2912 ParmVarDecl *Param 2913 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getParam())); 2914 if (!Param) 2915 return SemaRef.ExprError(); 2916 2917 if (getDerived().AlwaysRebuild() && 2918 Param == E->getParam()) 2919 return SemaRef.Owned(E->Retain()); 2920 2921 return getDerived().RebuildCXXDefaultArgExpr(Param); 2922} 2923 2924template<typename Derived> 2925Sema::OwningExprResult 2926TreeTransform<Derived>::TransformCXXZeroInitValueExpr(CXXZeroInitValueExpr *E) { 2927 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 2928 2929 QualType T = getDerived().TransformType(E->getType()); 2930 if (T.isNull()) 2931 return SemaRef.ExprError(); 2932 2933 if (!getDerived().AlwaysRebuild() && 2934 T == E->getType()) 2935 return SemaRef.Owned(E->Retain()); 2936 2937 return getDerived().RebuildCXXZeroInitValueExpr(E->getTypeBeginLoc(), 2938 /*FIXME:*/E->getTypeBeginLoc(), 2939 T, 2940 E->getRParenLoc()); 2941} 2942 2943template<typename Derived> 2944Sema::OwningExprResult 2945TreeTransform<Derived>::TransformCXXConditionDeclExpr(CXXConditionDeclExpr *E) { 2946 VarDecl *Var 2947 = cast_or_null<VarDecl>(getDerived().TransformDecl(E->getVarDecl())); 2948 if (!Var) 2949 return SemaRef.ExprError(); 2950 2951 if (!getDerived().AlwaysRebuild() && 2952 Var == E->getVarDecl()) 2953 return SemaRef.Owned(E->Retain()); 2954 2955 return getDerived().RebuildCXXConditionDeclExpr(E->getStartLoc(), 2956 /*FIXME:*/E->getStartLoc(), 2957 Var); 2958} 2959 2960template<typename Derived> 2961Sema::OwningExprResult 2962TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { 2963 // Transform the type that we're allocating 2964 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 2965 QualType AllocType = getDerived().TransformType(E->getAllocatedType()); 2966 if (AllocType.isNull()) 2967 return SemaRef.ExprError(); 2968 2969 // Transform the size of the array we're allocating (if any). 2970 OwningExprResult ArraySize = getDerived().TransformExpr(E->getArraySize()); 2971 if (ArraySize.isInvalid()) 2972 return SemaRef.ExprError(); 2973 2974 // Transform the placement arguments (if any). 2975 bool ArgumentChanged = false; 2976 ASTOwningVector<&ActionBase::DeleteExpr> PlacementArgs(SemaRef); 2977 for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) { 2978 OwningExprResult Arg = getDerived().TransformExpr(E->getPlacementArg(I)); 2979 if (Arg.isInvalid()) 2980 return SemaRef.ExprError(); 2981 2982 ArgumentChanged = ArgumentChanged || Arg.get() != E->getPlacementArg(I); 2983 PlacementArgs.push_back(Arg.take()); 2984 } 2985 2986 // Instantiate the constructor arguments (if any). 2987 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(SemaRef); 2988 for (unsigned I = 0, N = E->getNumConstructorArgs(); I != N; ++I) { 2989 OwningExprResult Arg = getDerived().TransformExpr(E->getConstructorArg(I)); 2990 if (Arg.isInvalid()) 2991 return SemaRef.ExprError(); 2992 2993 ArgumentChanged = ArgumentChanged || Arg.get() != E->getConstructorArg(I); 2994 ConstructorArgs.push_back(Arg.take()); 2995 } 2996 2997 if (!getDerived().AlwaysRebuild() && 2998 AllocType == E->getAllocatedType() && 2999 ArraySize.get() == E->getArraySize() && 3000 !ArgumentChanged) 3001 return SemaRef.Owned(E->Retain()); 3002 3003 return getDerived().RebuildCXXNewExpr(E->getLocStart(), 3004 E->isGlobalNew(), 3005 /*FIXME:*/E->getLocStart(), 3006 move_arg(PlacementArgs), 3007 /*FIXME:*/E->getLocStart(), 3008 E->isParenTypeId(), 3009 AllocType, 3010 /*FIXME:*/E->getLocStart(), 3011 /*FIXME:*/SourceRange(), 3012 move(ArraySize), 3013 /*FIXME:*/E->getLocStart(), 3014 move_arg(ConstructorArgs), 3015 E->getLocEnd()); 3016} 3017 3018template<typename Derived> 3019Sema::OwningExprResult 3020TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) { 3021 OwningExprResult Operand = getDerived().TransformExpr(E->getArgument()); 3022 if (Operand.isInvalid()) 3023 return SemaRef.ExprError(); 3024 3025 if (!getDerived().AlwaysRebuild() && 3026 Operand.get() == E->getArgument()) 3027 return SemaRef.Owned(E->Retain()); 3028 3029 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(), 3030 E->isGlobalDelete(), 3031 E->isArrayForm(), 3032 move(Operand)); 3033} 3034 3035template<typename Derived> 3036Sema::OwningExprResult 3037TreeTransform<Derived>::TransformUnresolvedFunctionNameExpr( 3038 UnresolvedFunctionNameExpr *E) { 3039 // There is no transformation we can apply to an unresolved function name. 3040 return SemaRef.Owned(E->Retain()); 3041} 3042 3043template<typename Derived> 3044Sema::OwningExprResult 3045TreeTransform<Derived>::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { 3046 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 3047 3048 QualType T = getDerived().TransformType(E->getQueriedType()); 3049 if (T.isNull()) 3050 return SemaRef.ExprError(); 3051 3052 if (!getDerived().AlwaysRebuild() && 3053 T == E->getQueriedType()) 3054 return SemaRef.Owned(E->Retain()); 3055 3056 // FIXME: Bad location information 3057 SourceLocation FakeLParenLoc 3058 = SemaRef.PP.getLocForEndOfToken(E->getLocStart()); 3059 3060 return getDerived().RebuildUnaryTypeTrait(E->getTrait(), 3061 E->getLocStart(), 3062 /*FIXME:*/FakeLParenLoc, 3063 T, 3064 E->getLocEnd()); 3065} 3066 3067template<typename Derived> 3068Sema::OwningExprResult 3069TreeTransform<Derived>::TransformQualifiedDeclRefExpr(QualifiedDeclRefExpr *E) { 3070 NestedNameSpecifier *NNS 3071 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 3072 E->getQualifierRange()); 3073 if (!NNS) 3074 return SemaRef.ExprError(); 3075 3076 NamedDecl *ND 3077 = dyn_cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getDecl())); 3078 if (!ND) 3079 return SemaRef.ExprError(); 3080 3081 if (!getDerived().AlwaysRebuild() && 3082 NNS == E->getQualifier() && 3083 ND == E->getDecl()) 3084 return SemaRef.Owned(E->Retain()); 3085 3086 return getDerived().RebuildQualifiedDeclRefExpr(NNS, 3087 E->getQualifierRange(), 3088 ND, 3089 E->getLocation(), 3090 /*FIXME:*/false); 3091} 3092 3093template<typename Derived> 3094Sema::OwningExprResult 3095TreeTransform<Derived>::TransformUnresolvedDeclRefExpr( 3096 UnresolvedDeclRefExpr *E) { 3097 NestedNameSpecifier *NNS 3098 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 3099 E->getQualifierRange()); 3100 if (!NNS) 3101 return SemaRef.ExprError(); 3102 3103 // FIXME: Transform the declaration name 3104 DeclarationName Name = E->getDeclName(); 3105 3106 if (!getDerived().AlwaysRebuild() && 3107 NNS == E->getQualifier() && 3108 Name == E->getDeclName()) 3109 return SemaRef.Owned(E->Retain()); 3110 3111 return getDerived().RebuildUnresolvedDeclRefExpr(NNS, 3112 E->getQualifierRange(), 3113 Name, 3114 E->getLocation(), 3115 /*FIXME:*/false); 3116} 3117 3118template<typename Derived> 3119Sema::OwningExprResult 3120TreeTransform<Derived>::TransformTemplateIdRefExpr(TemplateIdRefExpr *E) { 3121 TemplateName Template 3122 = getDerived().TransformTemplateName(E->getTemplateName()); 3123 if (Template.isNull()) 3124 return SemaRef.ExprError(); 3125 3126 llvm::SmallVector<TemplateArgument, 4> TransArgs; 3127 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 3128 TemplateArgument TransArg 3129 = getDerived().TransformTemplateArgument(E->getTemplateArgs()[I]); 3130 if (TransArg.isNull()) 3131 return SemaRef.ExprError(); 3132 3133 TransArgs.push_back(TransArg); 3134 } 3135 3136 // FIXME: Would like to avoid rebuilding if nothing changed, but we can't 3137 // compare template arguments (yet). 3138 3139 // FIXME: It's possible that we'll find out now that the template name 3140 // actually refers to a type, in which case the caller is actually dealing 3141 // with a functional cast. Give a reasonable error message! 3142 return getDerived().RebuildTemplateIdExpr(Template, E->getTemplateNameLoc(), 3143 E->getLAngleLoc(), 3144 TransArgs.data(), 3145 TransArgs.size(), 3146 E->getRAngleLoc()); 3147} 3148 3149template<typename Derived> 3150Sema::OwningExprResult 3151TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) { 3152 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 3153 3154 QualType T = getDerived().TransformType(E->getType()); 3155 if (T.isNull()) 3156 return SemaRef.ExprError(); 3157 3158 CXXConstructorDecl *Constructor 3159 = cast_or_null<CXXConstructorDecl>( 3160 getDerived().TransformDecl(E->getConstructor())); 3161 if (!Constructor) 3162 return SemaRef.ExprError(); 3163 3164 bool ArgumentChanged = false; 3165 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 3166 for (CXXConstructExpr::arg_iterator Arg = E->arg_begin(), 3167 ArgEnd = E->arg_end(); 3168 Arg != ArgEnd; ++Arg) { 3169 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 3170 if (TransArg.isInvalid()) 3171 return SemaRef.ExprError(); 3172 3173 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 3174 Args.push_back(TransArg.takeAs<Expr>()); 3175 } 3176 3177 if (!getDerived().AlwaysRebuild() && 3178 T == E->getType() && 3179 Constructor == E->getConstructor() && 3180 !ArgumentChanged) 3181 return SemaRef.Owned(E->Retain()); 3182 3183 return getDerived().RebuildCXXConstructExpr(T, Constructor, E->isElidable(), 3184 move_arg(Args)); 3185} 3186 3187/// \brief Transform a C++ temporary-binding expression. 3188/// 3189/// The transformation of a temporary-binding expression always attempts to 3190/// bind a new temporary variable to its subexpression, even if the 3191/// subexpression itself did not change, because the temporary variable itself 3192/// must be unique. 3193template<typename Derived> 3194Sema::OwningExprResult 3195TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 3196 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 3197 if (SubExpr.isInvalid()) 3198 return SemaRef.ExprError(); 3199 3200 return SemaRef.MaybeBindToTemporary(SubExpr.takeAs<Expr>()); 3201} 3202 3203/// \brief Transform a C++ expression that contains temporaries that should 3204/// be destroyed after the expression is evaluated. 3205/// 3206/// The transformation of a full expression always attempts to build a new 3207/// CXXExprWithTemporaries expression, even if the 3208/// subexpression itself did not change, because it will need to capture the 3209/// the new temporary variables introduced in the subexpression. 3210template<typename Derived> 3211Sema::OwningExprResult 3212TreeTransform<Derived>::TransformCXXExprWithTemporaries( 3213 CXXExprWithTemporaries *E) { 3214 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 3215 if (SubExpr.isInvalid()) 3216 return SemaRef.ExprError(); 3217 3218 return SemaRef.Owned( 3219 SemaRef.MaybeCreateCXXExprWithTemporaries(SubExpr.takeAs<Expr>(), 3220 E->shouldDestroyTemporaries())); 3221} 3222 3223template<typename Derived> 3224Sema::OwningExprResult 3225TreeTransform<Derived>::TransformCXXTemporaryObjectExpr( 3226 CXXTemporaryObjectExpr *E) { 3227 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 3228 QualType T = getDerived().TransformType(E->getType()); 3229 if (T.isNull()) 3230 return SemaRef.ExprError(); 3231 3232 CXXConstructorDecl *Constructor 3233 = cast_or_null<CXXConstructorDecl>( 3234 getDerived().TransformDecl(E->getConstructor())); 3235 if (!Constructor) 3236 return SemaRef.ExprError(); 3237 3238 bool ArgumentChanged = false; 3239 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 3240 Args.reserve(E->getNumArgs()); 3241 for (CXXTemporaryObjectExpr::arg_iterator Arg = E->arg_begin(), 3242 ArgEnd = E->arg_end(); 3243 Arg != ArgEnd; ++Arg) { 3244 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 3245 if (TransArg.isInvalid()) 3246 return SemaRef.ExprError(); 3247 3248 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 3249 Args.push_back((Expr *)TransArg.release()); 3250 } 3251 3252 if (!getDerived().AlwaysRebuild() && 3253 T == E->getType() && 3254 Constructor == E->getConstructor() && 3255 !ArgumentChanged) 3256 return SemaRef.Owned(E->Retain()); 3257 3258 // FIXME: Bogus location information 3259 SourceLocation CommaLoc; 3260 if (Args.size() > 1) { 3261 Expr *First = (Expr *)Args[0]; 3262 CommaLoc 3263 = SemaRef.PP.getLocForEndOfToken(First->getSourceRange().getEnd()); 3264 } 3265 return getDerived().RebuildCXXTemporaryObjectExpr(E->getTypeBeginLoc(), 3266 T, 3267 /*FIXME:*/E->getTypeBeginLoc(), 3268 move_arg(Args), 3269 &CommaLoc, 3270 E->getLocEnd()); 3271} 3272 3273template<typename Derived> 3274Sema::OwningExprResult 3275TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( 3276 CXXUnresolvedConstructExpr *E) { 3277 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 3278 QualType T = getDerived().TransformType(E->getTypeAsWritten()); 3279 if (T.isNull()) 3280 return SemaRef.ExprError(); 3281 3282 bool ArgumentChanged = false; 3283 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 3284 llvm::SmallVector<SourceLocation, 8> FakeCommaLocs; 3285 for (CXXUnresolvedConstructExpr::arg_iterator Arg = E->arg_begin(), 3286 ArgEnd = E->arg_end(); 3287 Arg != ArgEnd; ++Arg) { 3288 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 3289 if (TransArg.isInvalid()) 3290 return SemaRef.ExprError(); 3291 3292 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 3293 FakeCommaLocs.push_back( 3294 SemaRef.PP.getLocForEndOfToken((*Arg)->getLocEnd())); 3295 Args.push_back(TransArg.takeAs<Expr>()); 3296 } 3297 3298 if (!getDerived().AlwaysRebuild() && 3299 T == E->getTypeAsWritten() && 3300 !ArgumentChanged) 3301 return SemaRef.Owned(E->Retain()); 3302 3303 // FIXME: we're faking the locations of the commas 3304 return getDerived().RebuildCXXUnresolvedConstructExpr(E->getTypeBeginLoc(), 3305 T, 3306 E->getLParenLoc(), 3307 move_arg(Args), 3308 FakeCommaLocs.data(), 3309 E->getRParenLoc()); 3310} 3311 3312template<typename Derived> 3313Sema::OwningExprResult 3314TreeTransform<Derived>::TransformCXXUnresolvedMemberExpr( 3315 CXXUnresolvedMemberExpr *E) { 3316 // Transform the base of the expression. 3317 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 3318 if (Base.isInvalid()) 3319 return SemaRef.ExprError(); 3320 3321 // FIXME: Transform the declaration name 3322 DeclarationName Name = E->getMember(); 3323 3324 if (!getDerived().AlwaysRebuild() && 3325 Base.get() == E->getBase() && 3326 Name == E->getMember()) 3327 return SemaRef.Owned(E->Retain()); 3328 3329 return getDerived().RebuildCXXUnresolvedMemberExpr(move(Base), 3330 E->isArrow(), 3331 E->getOperatorLoc(), 3332 E->getMember(), 3333 E->getMemberLoc()); 3334} 3335 3336template<typename Derived> 3337Sema::OwningExprResult 3338TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) { 3339 return SemaRef.Owned(E->Retain()); 3340} 3341 3342template<typename Derived> 3343Sema::OwningExprResult 3344TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) { 3345 // FIXME: poor source location 3346 TemporaryBase Rebase(*this, E->getAtLoc(), DeclarationName()); 3347 QualType EncodedType = getDerived().TransformType(E->getEncodedType()); 3348 if (EncodedType.isNull()) 3349 return SemaRef.ExprError(); 3350 3351 if (!getDerived().AlwaysRebuild() && 3352 EncodedType == E->getEncodedType()) 3353 return SemaRef.Owned(E->Retain()); 3354 3355 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(), 3356 EncodedType, 3357 E->getRParenLoc()); 3358} 3359 3360template<typename Derived> 3361Sema::OwningExprResult 3362TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) { 3363 // FIXME: Implement this! 3364 assert(false && "Cannot transform Objective-C expressions yet"); 3365 return SemaRef.Owned(E->Retain()); 3366} 3367 3368template<typename Derived> 3369Sema::OwningExprResult 3370TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) { 3371 return SemaRef.Owned(E->Retain()); 3372} 3373 3374template<typename Derived> 3375Sema::OwningExprResult 3376TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) { 3377 ObjCProtocolDecl *Protocol 3378 = cast_or_null<ObjCProtocolDecl>( 3379 getDerived().TransformDecl(E->getProtocol())); 3380 if (!Protocol) 3381 return SemaRef.ExprError(); 3382 3383 if (!getDerived().AlwaysRebuild() && 3384 Protocol == E->getProtocol()) 3385 return SemaRef.Owned(E->Retain()); 3386 3387 return getDerived().RebuildObjCProtocolExpr(Protocol, 3388 E->getAtLoc(), 3389 /*FIXME:*/E->getAtLoc(), 3390 /*FIXME:*/E->getAtLoc(), 3391 E->getRParenLoc()); 3392 3393} 3394 3395template<typename Derived> 3396Sema::OwningExprResult 3397TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) { 3398 // FIXME: Implement this! 3399 assert(false && "Cannot transform Objective-C expressions yet"); 3400 return SemaRef.Owned(E->Retain()); 3401} 3402 3403template<typename Derived> 3404Sema::OwningExprResult 3405TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 3406 // FIXME: Implement this! 3407 assert(false && "Cannot transform Objective-C expressions yet"); 3408 return SemaRef.Owned(E->Retain()); 3409} 3410 3411template<typename Derived> 3412Sema::OwningExprResult 3413TreeTransform<Derived>::TransformObjCKVCRefExpr(ObjCKVCRefExpr *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