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