1 //===--- ExprCXX.cpp - (C++) Expression AST Node Implementation -----------===//
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 //
10 // This file implements the subclesses of Expr class declared in ExprCXX.h
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/Basic/IdentifierTable.h"
15 #include "clang/AST/DeclCXX.h"
16 #include "clang/AST/DeclTemplate.h"
17 #include "clang/AST/ExprCXX.h"
18 #include "clang/AST/TypeLoc.h"
19 using namespace clang;
20 
21 
22 //===----------------------------------------------------------------------===//
23 //  Child Iterators for iterating over subexpressions/substatements
24 //===----------------------------------------------------------------------===//
25 
26 QualType CXXTypeidExpr::getTypeOperand() const {
27   assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)");
28   return Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType()
29                                                         .getUnqualifiedType();
30 }
31 
32 QualType CXXUuidofExpr::getTypeOperand() const {
33   assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)");
34   return Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType()
35                                                         .getUnqualifiedType();
36 }
37 
38 // CXXScalarValueInitExpr
39 SourceRange CXXScalarValueInitExpr::getSourceRange() const {
40   SourceLocation Start = RParenLoc;
41   if (TypeInfo)
42     Start = TypeInfo->getTypeLoc().getBeginLoc();
43   return SourceRange(Start, RParenLoc);
44 }
45 
46 // CXXNewExpr
47 CXXNewExpr::CXXNewExpr(ASTContext &C, bool globalNew, FunctionDecl *operatorNew,
48                        Expr **placementArgs, unsigned numPlaceArgs,
49                        SourceRange TypeIdParens, Expr *arraySize,
50                        CXXConstructorDecl *constructor, bool initializer,
51                        Expr **constructorArgs, unsigned numConsArgs,
52                        bool HadMultipleCandidates,
53                        FunctionDecl *operatorDelete,
54                        bool usualArrayDeleteWantsSize, QualType ty,
55                        TypeSourceInfo *AllocatedTypeInfo,
56                        SourceLocation startLoc, SourceLocation endLoc,
57                        SourceLocation constructorLParen,
58                        SourceLocation constructorRParen)
59   : Expr(CXXNewExprClass, ty, VK_RValue, OK_Ordinary,
60          ty->isDependentType(), ty->isDependentType(),
61          ty->isInstantiationDependentType(),
62          ty->containsUnexpandedParameterPack()),
63     GlobalNew(globalNew), Initializer(initializer),
64     UsualArrayDeleteWantsSize(usualArrayDeleteWantsSize),
65     HadMultipleCandidates(HadMultipleCandidates),
66     SubExprs(0), OperatorNew(operatorNew),
67     OperatorDelete(operatorDelete), Constructor(constructor),
68     AllocatedTypeInfo(AllocatedTypeInfo), TypeIdParens(TypeIdParens),
69     StartLoc(startLoc), EndLoc(endLoc), ConstructorLParen(constructorLParen),
70     ConstructorRParen(constructorRParen) {
71   AllocateArgsArray(C, arraySize != 0, numPlaceArgs, numConsArgs);
72   unsigned i = 0;
73   if (Array) {
74     if (arraySize->isInstantiationDependent())
75       ExprBits.InstantiationDependent = true;
76 
77     if (arraySize->containsUnexpandedParameterPack())
78       ExprBits.ContainsUnexpandedParameterPack = true;
79 
80     SubExprs[i++] = arraySize;
81   }
82 
83   for (unsigned j = 0; j < NumPlacementArgs; ++j) {
84     if (placementArgs[j]->isInstantiationDependent())
85       ExprBits.InstantiationDependent = true;
86     if (placementArgs[j]->containsUnexpandedParameterPack())
87       ExprBits.ContainsUnexpandedParameterPack = true;
88 
89     SubExprs[i++] = placementArgs[j];
90   }
91 
92   for (unsigned j = 0; j < NumConstructorArgs; ++j) {
93     if (constructorArgs[j]->isInstantiationDependent())
94       ExprBits.InstantiationDependent = true;
95     if (constructorArgs[j]->containsUnexpandedParameterPack())
96       ExprBits.ContainsUnexpandedParameterPack = true;
97 
98     SubExprs[i++] = constructorArgs[j];
99   }
100 }
101 
102 void CXXNewExpr::AllocateArgsArray(ASTContext &C, bool isArray,
103                                    unsigned numPlaceArgs, unsigned numConsArgs){
104   assert(SubExprs == 0 && "SubExprs already allocated");
105   Array = isArray;
106   NumPlacementArgs = numPlaceArgs;
107   NumConstructorArgs = numConsArgs;
108 
109   unsigned TotalSize = Array + NumPlacementArgs + NumConstructorArgs;
110   SubExprs = new (C) Stmt*[TotalSize];
111 }
112 
113 bool CXXNewExpr::shouldNullCheckAllocation(ASTContext &Ctx) const {
114   return getOperatorNew()->getType()->
115     castAs<FunctionProtoType>()->isNothrow(Ctx);
116 }
117 
118 // CXXDeleteExpr
119 QualType CXXDeleteExpr::getDestroyedType() const {
120   const Expr *Arg = getArgument();
121   while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
122     if (ICE->getCastKind() != CK_UserDefinedConversion &&
123         ICE->getType()->isVoidPointerType())
124       Arg = ICE->getSubExpr();
125     else
126       break;
127   }
128   // The type-to-delete may not be a pointer if it's a dependent type.
129   const QualType ArgType = Arg->getType();
130 
131   if (ArgType->isDependentType() && !ArgType->isPointerType())
132     return QualType();
133 
134   return ArgType->getAs<PointerType>()->getPointeeType();
135 }
136 
137 // CXXPseudoDestructorExpr
138 PseudoDestructorTypeStorage::PseudoDestructorTypeStorage(TypeSourceInfo *Info)
139  : Type(Info)
140 {
141   Location = Info->getTypeLoc().getLocalSourceRange().getBegin();
142 }
143 
144 CXXPseudoDestructorExpr::CXXPseudoDestructorExpr(ASTContext &Context,
145                 Expr *Base, bool isArrow, SourceLocation OperatorLoc,
146                 NestedNameSpecifierLoc QualifierLoc, TypeSourceInfo *ScopeType,
147                 SourceLocation ColonColonLoc, SourceLocation TildeLoc,
148                 PseudoDestructorTypeStorage DestroyedType)
149   : Expr(CXXPseudoDestructorExprClass,
150          Context.getPointerType(Context.getFunctionType(Context.VoidTy, 0, 0,
151                                          FunctionProtoType::ExtProtoInfo())),
152          VK_RValue, OK_Ordinary,
153          /*isTypeDependent=*/(Base->isTypeDependent() ||
154            (DestroyedType.getTypeSourceInfo() &&
155             DestroyedType.getTypeSourceInfo()->getType()->isDependentType())),
156          /*isValueDependent=*/Base->isValueDependent(),
157          (Base->isInstantiationDependent() ||
158           (QualifierLoc &&
159            QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent()) ||
160           (ScopeType &&
161            ScopeType->getType()->isInstantiationDependentType()) ||
162           (DestroyedType.getTypeSourceInfo() &&
163            DestroyedType.getTypeSourceInfo()->getType()
164                                              ->isInstantiationDependentType())),
165          // ContainsUnexpandedParameterPack
166          (Base->containsUnexpandedParameterPack() ||
167           (QualifierLoc &&
168            QualifierLoc.getNestedNameSpecifier()
169                                         ->containsUnexpandedParameterPack()) ||
170           (ScopeType &&
171            ScopeType->getType()->containsUnexpandedParameterPack()) ||
172           (DestroyedType.getTypeSourceInfo() &&
173            DestroyedType.getTypeSourceInfo()->getType()
174                                    ->containsUnexpandedParameterPack()))),
175     Base(static_cast<Stmt *>(Base)), IsArrow(isArrow),
176     OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),
177     ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc),
178     DestroyedType(DestroyedType) { }
179 
180 QualType CXXPseudoDestructorExpr::getDestroyedType() const {
181   if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())
182     return TInfo->getType();
183 
184   return QualType();
185 }
186 
187 SourceRange CXXPseudoDestructorExpr::getSourceRange() const {
188   SourceLocation End = DestroyedType.getLocation();
189   if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())
190     End = TInfo->getTypeLoc().getLocalSourceRange().getEnd();
191   return SourceRange(Base->getLocStart(), End);
192 }
193 
194 
195 // UnresolvedLookupExpr
196 UnresolvedLookupExpr *
197 UnresolvedLookupExpr::Create(ASTContext &C,
198                              CXXRecordDecl *NamingClass,
199                              NestedNameSpecifierLoc QualifierLoc,
200                              const DeclarationNameInfo &NameInfo,
201                              bool ADL,
202                              const TemplateArgumentListInfo &Args,
203                              UnresolvedSetIterator Begin,
204                              UnresolvedSetIterator End)
205 {
206   void *Mem = C.Allocate(sizeof(UnresolvedLookupExpr) +
207                          ASTTemplateArgumentListInfo::sizeFor(Args));
208   return new (Mem) UnresolvedLookupExpr(C, NamingClass, QualifierLoc, NameInfo,
209                                         ADL, /*Overload*/ true, &Args,
210                                         Begin, End, /*StdIsAssociated=*/false);
211 }
212 
213 UnresolvedLookupExpr *
214 UnresolvedLookupExpr::CreateEmpty(ASTContext &C, bool HasExplicitTemplateArgs,
215                                   unsigned NumTemplateArgs) {
216   std::size_t size = sizeof(UnresolvedLookupExpr);
217   if (HasExplicitTemplateArgs)
218     size += ASTTemplateArgumentListInfo::sizeFor(NumTemplateArgs);
219 
220   void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedLookupExpr>());
221   UnresolvedLookupExpr *E = new (Mem) UnresolvedLookupExpr(EmptyShell());
222   E->HasExplicitTemplateArgs = HasExplicitTemplateArgs;
223   return E;
224 }
225 
226 OverloadExpr::OverloadExpr(StmtClass K, ASTContext &C,
227                            NestedNameSpecifierLoc QualifierLoc,
228                            const DeclarationNameInfo &NameInfo,
229                            const TemplateArgumentListInfo *TemplateArgs,
230                            UnresolvedSetIterator Begin,
231                            UnresolvedSetIterator End,
232                            bool KnownDependent,
233                            bool KnownInstantiationDependent,
234                            bool KnownContainsUnexpandedParameterPack)
235   : Expr(K, C.OverloadTy, VK_LValue, OK_Ordinary, KnownDependent,
236          KnownDependent,
237          (KnownInstantiationDependent ||
238           NameInfo.isInstantiationDependent() ||
239           (QualifierLoc &&
240            QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())),
241          (KnownContainsUnexpandedParameterPack ||
242           NameInfo.containsUnexpandedParameterPack() ||
243           (QualifierLoc &&
244            QualifierLoc.getNestedNameSpecifier()
245                                       ->containsUnexpandedParameterPack()))),
246     Results(0), NumResults(End - Begin), NameInfo(NameInfo),
247     QualifierLoc(QualifierLoc), HasExplicitTemplateArgs(TemplateArgs != 0)
248 {
249   NumResults = End - Begin;
250   if (NumResults) {
251     // Determine whether this expression is type-dependent.
252     for (UnresolvedSetImpl::const_iterator I = Begin; I != End; ++I) {
253       if ((*I)->getDeclContext()->isDependentContext() ||
254           isa<UnresolvedUsingValueDecl>(*I)) {
255         ExprBits.TypeDependent = true;
256         ExprBits.ValueDependent = true;
257       }
258     }
259 
260     Results = static_cast<DeclAccessPair *>(
261                                 C.Allocate(sizeof(DeclAccessPair) * NumResults,
262                                            llvm::alignOf<DeclAccessPair>()));
263     memcpy(Results, &*Begin.getIterator(),
264            NumResults * sizeof(DeclAccessPair));
265   }
266 
267   // If we have explicit template arguments, check for dependent
268   // template arguments and whether they contain any unexpanded pack
269   // expansions.
270   if (TemplateArgs) {
271     bool Dependent = false;
272     bool InstantiationDependent = false;
273     bool ContainsUnexpandedParameterPack = false;
274     getExplicitTemplateArgs().initializeFrom(*TemplateArgs, Dependent,
275                                              InstantiationDependent,
276                                              ContainsUnexpandedParameterPack);
277 
278     if (Dependent) {
279       ExprBits.TypeDependent = true;
280       ExprBits.ValueDependent = true;
281     }
282     if (InstantiationDependent)
283       ExprBits.InstantiationDependent = true;
284     if (ContainsUnexpandedParameterPack)
285       ExprBits.ContainsUnexpandedParameterPack = true;
286   }
287 
288   if (isTypeDependent())
289     setType(C.DependentTy);
290 }
291 
292 void OverloadExpr::initializeResults(ASTContext &C,
293                                      UnresolvedSetIterator Begin,
294                                      UnresolvedSetIterator End) {
295   assert(Results == 0 && "Results already initialized!");
296   NumResults = End - Begin;
297   if (NumResults) {
298      Results = static_cast<DeclAccessPair *>(
299                                C.Allocate(sizeof(DeclAccessPair) * NumResults,
300 
301                                           llvm::alignOf<DeclAccessPair>()));
302      memcpy(Results, &*Begin.getIterator(),
303             NumResults * sizeof(DeclAccessPair));
304   }
305 }
306 
307 CXXRecordDecl *OverloadExpr::getNamingClass() const {
308   if (isa<UnresolvedLookupExpr>(this))
309     return cast<UnresolvedLookupExpr>(this)->getNamingClass();
310   else
311     return cast<UnresolvedMemberExpr>(this)->getNamingClass();
312 }
313 
314 // DependentScopeDeclRefExpr
315 DependentScopeDeclRefExpr::DependentScopeDeclRefExpr(QualType T,
316                             NestedNameSpecifierLoc QualifierLoc,
317                             const DeclarationNameInfo &NameInfo,
318                             const TemplateArgumentListInfo *Args)
319   : Expr(DependentScopeDeclRefExprClass, T, VK_LValue, OK_Ordinary,
320          true, true,
321          (NameInfo.isInstantiationDependent() ||
322           (QualifierLoc &&
323            QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())),
324          (NameInfo.containsUnexpandedParameterPack() ||
325           (QualifierLoc &&
326            QualifierLoc.getNestedNameSpecifier()
327                             ->containsUnexpandedParameterPack()))),
328     QualifierLoc(QualifierLoc), NameInfo(NameInfo),
329     HasExplicitTemplateArgs(Args != 0)
330 {
331   if (Args) {
332     bool Dependent = true;
333     bool InstantiationDependent = true;
334     bool ContainsUnexpandedParameterPack
335       = ExprBits.ContainsUnexpandedParameterPack;
336 
337     reinterpret_cast<ASTTemplateArgumentListInfo*>(this+1)
338       ->initializeFrom(*Args, Dependent, InstantiationDependent,
339                        ContainsUnexpandedParameterPack);
340 
341     ExprBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack;
342   }
343 }
344 
345 DependentScopeDeclRefExpr *
346 DependentScopeDeclRefExpr::Create(ASTContext &C,
347                                   NestedNameSpecifierLoc QualifierLoc,
348                                   const DeclarationNameInfo &NameInfo,
349                                   const TemplateArgumentListInfo *Args) {
350   std::size_t size = sizeof(DependentScopeDeclRefExpr);
351   if (Args)
352     size += ASTTemplateArgumentListInfo::sizeFor(*Args);
353   void *Mem = C.Allocate(size);
354   return new (Mem) DependentScopeDeclRefExpr(C.DependentTy, QualifierLoc,
355                                              NameInfo, Args);
356 }
357 
358 DependentScopeDeclRefExpr *
359 DependentScopeDeclRefExpr::CreateEmpty(ASTContext &C,
360                                        bool HasExplicitTemplateArgs,
361                                        unsigned NumTemplateArgs) {
362   std::size_t size = sizeof(DependentScopeDeclRefExpr);
363   if (HasExplicitTemplateArgs)
364     size += ASTTemplateArgumentListInfo::sizeFor(NumTemplateArgs);
365   void *Mem = C.Allocate(size);
366   DependentScopeDeclRefExpr *E
367     = new (Mem) DependentScopeDeclRefExpr(QualType(), NestedNameSpecifierLoc(),
368                                           DeclarationNameInfo(), 0);
369   E->HasExplicitTemplateArgs = HasExplicitTemplateArgs;
370   return E;
371 }
372 
373 SourceRange CXXConstructExpr::getSourceRange() const {
374   if (isa<CXXTemporaryObjectExpr>(this))
375     return cast<CXXTemporaryObjectExpr>(this)->getSourceRange();
376 
377   if (ParenRange.isValid())
378     return SourceRange(Loc, ParenRange.getEnd());
379 
380   SourceLocation End = Loc;
381   for (unsigned I = getNumArgs(); I > 0; --I) {
382     const Expr *Arg = getArg(I-1);
383     if (!Arg->isDefaultArgument()) {
384       SourceLocation NewEnd = Arg->getLocEnd();
385       if (NewEnd.isValid()) {
386         End = NewEnd;
387         break;
388       }
389     }
390   }
391 
392   return SourceRange(Loc, End);
393 }
394 
395 SourceRange CXXOperatorCallExpr::getSourceRange() const {
396   OverloadedOperatorKind Kind = getOperator();
397   if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
398     if (getNumArgs() == 1)
399       // Prefix operator
400       return SourceRange(getOperatorLoc(),
401                          getArg(0)->getSourceRange().getEnd());
402     else
403       // Postfix operator
404       return SourceRange(getArg(0)->getSourceRange().getBegin(),
405                          getOperatorLoc());
406   } else if (Kind == OO_Arrow) {
407     return getArg(0)->getSourceRange();
408   } else if (Kind == OO_Call) {
409     return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc());
410   } else if (Kind == OO_Subscript) {
411     return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc());
412   } else if (getNumArgs() == 1) {
413     return SourceRange(getOperatorLoc(), getArg(0)->getSourceRange().getEnd());
414   } else if (getNumArgs() == 2) {
415     return SourceRange(getArg(0)->getSourceRange().getBegin(),
416                        getArg(1)->getSourceRange().getEnd());
417   } else {
418     return SourceRange();
419   }
420 }
421 
422 Expr *CXXMemberCallExpr::getImplicitObjectArgument() const {
423   if (const MemberExpr *MemExpr =
424         dyn_cast<MemberExpr>(getCallee()->IgnoreParens()))
425     return MemExpr->getBase();
426 
427   // FIXME: Will eventually need to cope with member pointers.
428   return 0;
429 }
430 
431 CXXMethodDecl *CXXMemberCallExpr::getMethodDecl() const {
432   if (const MemberExpr *MemExpr =
433       dyn_cast<MemberExpr>(getCallee()->IgnoreParens()))
434     return cast<CXXMethodDecl>(MemExpr->getMemberDecl());
435 
436   // FIXME: Will eventually need to cope with member pointers.
437   return 0;
438 }
439 
440 
441 CXXRecordDecl *CXXMemberCallExpr::getRecordDecl() {
442   Expr* ThisArg = getImplicitObjectArgument();
443   if (!ThisArg)
444     return 0;
445 
446   if (ThisArg->getType()->isAnyPointerType())
447     return ThisArg->getType()->getPointeeType()->getAsCXXRecordDecl();
448 
449   return ThisArg->getType()->getAsCXXRecordDecl();
450 }
451 
452 
453 //===----------------------------------------------------------------------===//
454 //  Named casts
455 //===----------------------------------------------------------------------===//
456 
457 /// getCastName - Get the name of the C++ cast being used, e.g.,
458 /// "static_cast", "dynamic_cast", "reinterpret_cast", or
459 /// "const_cast". The returned pointer must not be freed.
460 const char *CXXNamedCastExpr::getCastName() const {
461   switch (getStmtClass()) {
462   case CXXStaticCastExprClass:      return "static_cast";
463   case CXXDynamicCastExprClass:     return "dynamic_cast";
464   case CXXReinterpretCastExprClass: return "reinterpret_cast";
465   case CXXConstCastExprClass:       return "const_cast";
466   default:                          return "<invalid cast>";
467   }
468 }
469 
470 CXXStaticCastExpr *CXXStaticCastExpr::Create(ASTContext &C, QualType T,
471                                              ExprValueKind VK,
472                                              CastKind K, Expr *Op,
473                                              const CXXCastPath *BasePath,
474                                              TypeSourceInfo *WrittenTy,
475                                              SourceLocation L,
476                                              SourceLocation RParenLoc) {
477   unsigned PathSize = (BasePath ? BasePath->size() : 0);
478   void *Buffer = C.Allocate(sizeof(CXXStaticCastExpr)
479                             + PathSize * sizeof(CXXBaseSpecifier*));
480   CXXStaticCastExpr *E =
481     new (Buffer) CXXStaticCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
482                                    RParenLoc);
483   if (PathSize) E->setCastPath(*BasePath);
484   return E;
485 }
486 
487 CXXStaticCastExpr *CXXStaticCastExpr::CreateEmpty(ASTContext &C,
488                                                   unsigned PathSize) {
489   void *Buffer =
490     C.Allocate(sizeof(CXXStaticCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
491   return new (Buffer) CXXStaticCastExpr(EmptyShell(), PathSize);
492 }
493 
494 CXXDynamicCastExpr *CXXDynamicCastExpr::Create(ASTContext &C, QualType T,
495                                                ExprValueKind VK,
496                                                CastKind K, Expr *Op,
497                                                const CXXCastPath *BasePath,
498                                                TypeSourceInfo *WrittenTy,
499                                                SourceLocation L,
500                                                SourceLocation RParenLoc) {
501   unsigned PathSize = (BasePath ? BasePath->size() : 0);
502   void *Buffer = C.Allocate(sizeof(CXXDynamicCastExpr)
503                             + PathSize * sizeof(CXXBaseSpecifier*));
504   CXXDynamicCastExpr *E =
505     new (Buffer) CXXDynamicCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
506                                     RParenLoc);
507   if (PathSize) E->setCastPath(*BasePath);
508   return E;
509 }
510 
511 CXXDynamicCastExpr *CXXDynamicCastExpr::CreateEmpty(ASTContext &C,
512                                                     unsigned PathSize) {
513   void *Buffer =
514     C.Allocate(sizeof(CXXDynamicCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
515   return new (Buffer) CXXDynamicCastExpr(EmptyShell(), PathSize);
516 }
517 
518 /// isAlwaysNull - Return whether the result of the dynamic_cast is proven
519 /// to always be null. For example:
520 ///
521 /// struct A { };
522 /// struct B final : A { };
523 /// struct C { };
524 ///
525 /// C *f(B* b) { return dynamic_cast<C*>(b); }
526 bool CXXDynamicCastExpr::isAlwaysNull() const
527 {
528   QualType SrcType = getSubExpr()->getType();
529   QualType DestType = getType();
530 
531   if (const PointerType *SrcPTy = SrcType->getAs<PointerType>()) {
532     SrcType = SrcPTy->getPointeeType();
533     DestType = DestType->castAs<PointerType>()->getPointeeType();
534   }
535 
536   const CXXRecordDecl *SrcRD =
537     cast<CXXRecordDecl>(SrcType->castAs<RecordType>()->getDecl());
538 
539   if (!SrcRD->hasAttr<FinalAttr>())
540     return false;
541 
542   const CXXRecordDecl *DestRD =
543     cast<CXXRecordDecl>(DestType->castAs<RecordType>()->getDecl());
544 
545   return !DestRD->isDerivedFrom(SrcRD);
546 }
547 
548 CXXReinterpretCastExpr *
549 CXXReinterpretCastExpr::Create(ASTContext &C, QualType T, ExprValueKind VK,
550                                CastKind K, Expr *Op,
551                                const CXXCastPath *BasePath,
552                                TypeSourceInfo *WrittenTy, SourceLocation L,
553                                SourceLocation RParenLoc) {
554   unsigned PathSize = (BasePath ? BasePath->size() : 0);
555   void *Buffer =
556     C.Allocate(sizeof(CXXReinterpretCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
557   CXXReinterpretCastExpr *E =
558     new (Buffer) CXXReinterpretCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
559                                         RParenLoc);
560   if (PathSize) E->setCastPath(*BasePath);
561   return E;
562 }
563 
564 CXXReinterpretCastExpr *
565 CXXReinterpretCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) {
566   void *Buffer = C.Allocate(sizeof(CXXReinterpretCastExpr)
567                             + PathSize * sizeof(CXXBaseSpecifier*));
568   return new (Buffer) CXXReinterpretCastExpr(EmptyShell(), PathSize);
569 }
570 
571 CXXConstCastExpr *CXXConstCastExpr::Create(ASTContext &C, QualType T,
572                                            ExprValueKind VK, Expr *Op,
573                                            TypeSourceInfo *WrittenTy,
574                                            SourceLocation L,
575                                            SourceLocation RParenLoc) {
576   return new (C) CXXConstCastExpr(T, VK, Op, WrittenTy, L, RParenLoc);
577 }
578 
579 CXXConstCastExpr *CXXConstCastExpr::CreateEmpty(ASTContext &C) {
580   return new (C) CXXConstCastExpr(EmptyShell());
581 }
582 
583 CXXFunctionalCastExpr *
584 CXXFunctionalCastExpr::Create(ASTContext &C, QualType T, ExprValueKind VK,
585                               TypeSourceInfo *Written, SourceLocation L,
586                               CastKind K, Expr *Op, const CXXCastPath *BasePath,
587                                SourceLocation R) {
588   unsigned PathSize = (BasePath ? BasePath->size() : 0);
589   void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr)
590                             + PathSize * sizeof(CXXBaseSpecifier*));
591   CXXFunctionalCastExpr *E =
592     new (Buffer) CXXFunctionalCastExpr(T, VK, Written, L, K, Op, PathSize, R);
593   if (PathSize) E->setCastPath(*BasePath);
594   return E;
595 }
596 
597 CXXFunctionalCastExpr *
598 CXXFunctionalCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) {
599   void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr)
600                             + PathSize * sizeof(CXXBaseSpecifier*));
601   return new (Buffer) CXXFunctionalCastExpr(EmptyShell(), PathSize);
602 }
603 
604 
605 CXXDefaultArgExpr *
606 CXXDefaultArgExpr::Create(ASTContext &C, SourceLocation Loc,
607                           ParmVarDecl *Param, Expr *SubExpr) {
608   void *Mem = C.Allocate(sizeof(CXXDefaultArgExpr) + sizeof(Stmt *));
609   return new (Mem) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param,
610                                      SubExpr);
611 }
612 
613 CXXTemporary *CXXTemporary::Create(ASTContext &C,
614                                    const CXXDestructorDecl *Destructor) {
615   return new (C) CXXTemporary(Destructor);
616 }
617 
618 CXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(ASTContext &C,
619                                                    CXXTemporary *Temp,
620                                                    Expr* SubExpr) {
621   assert(SubExpr->getType()->isRecordType() &&
622          "Expression bound to a temporary must have record type!");
623 
624   return new (C) CXXBindTemporaryExpr(Temp, SubExpr);
625 }
626 
627 CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(ASTContext &C,
628                                                CXXConstructorDecl *Cons,
629                                                TypeSourceInfo *Type,
630                                                Expr **Args,
631                                                unsigned NumArgs,
632                                                SourceRange parenRange,
633                                                bool HadMultipleCandidates,
634                                                bool ZeroInitialization)
635   : CXXConstructExpr(C, CXXTemporaryObjectExprClass,
636                      Type->getType().getNonReferenceType(),
637                      Type->getTypeLoc().getBeginLoc(),
638                      Cons, false, Args, NumArgs,
639                      HadMultipleCandidates, ZeroInitialization,
640                      CXXConstructExpr::CK_Complete, parenRange),
641     Type(Type) {
642 }
643 
644 SourceRange CXXTemporaryObjectExpr::getSourceRange() const {
645   return SourceRange(Type->getTypeLoc().getBeginLoc(),
646                      getParenRange().getEnd());
647 }
648 
649 CXXConstructExpr *CXXConstructExpr::Create(ASTContext &C, QualType T,
650                                            SourceLocation Loc,
651                                            CXXConstructorDecl *D, bool Elidable,
652                                            Expr **Args, unsigned NumArgs,
653                                            bool HadMultipleCandidates,
654                                            bool ZeroInitialization,
655                                            ConstructionKind ConstructKind,
656                                            SourceRange ParenRange) {
657   return new (C) CXXConstructExpr(C, CXXConstructExprClass, T, Loc, D,
658                                   Elidable, Args, NumArgs,
659                                   HadMultipleCandidates, ZeroInitialization,
660                                   ConstructKind, ParenRange);
661 }
662 
663 CXXConstructExpr::CXXConstructExpr(ASTContext &C, StmtClass SC, QualType T,
664                                    SourceLocation Loc,
665                                    CXXConstructorDecl *D, bool elidable,
666                                    Expr **args, unsigned numargs,
667                                    bool HadMultipleCandidates,
668                                    bool ZeroInitialization,
669                                    ConstructionKind ConstructKind,
670                                    SourceRange ParenRange)
671   : Expr(SC, T, VK_RValue, OK_Ordinary,
672          T->isDependentType(), T->isDependentType(),
673          T->isInstantiationDependentType(),
674          T->containsUnexpandedParameterPack()),
675     Constructor(D), Loc(Loc), ParenRange(ParenRange),  NumArgs(numargs),
676     Elidable(elidable), HadMultipleCandidates(HadMultipleCandidates),
677     ZeroInitialization(ZeroInitialization),
678     ConstructKind(ConstructKind), Args(0)
679 {
680   if (NumArgs) {
681     Args = new (C) Stmt*[NumArgs];
682 
683     for (unsigned i = 0; i != NumArgs; ++i) {
684       assert(args[i] && "NULL argument in CXXConstructExpr");
685 
686       if (args[i]->isValueDependent())
687         ExprBits.ValueDependent = true;
688       if (args[i]->isInstantiationDependent())
689         ExprBits.InstantiationDependent = true;
690       if (args[i]->containsUnexpandedParameterPack())
691         ExprBits.ContainsUnexpandedParameterPack = true;
692 
693       Args[i] = args[i];
694     }
695   }
696 }
697 
698 ExprWithCleanups::ExprWithCleanups(Expr *subexpr,
699                                    ArrayRef<CleanupObject> objects)
700   : Expr(ExprWithCleanupsClass, subexpr->getType(),
701          subexpr->getValueKind(), subexpr->getObjectKind(),
702          subexpr->isTypeDependent(), subexpr->isValueDependent(),
703          subexpr->isInstantiationDependent(),
704          subexpr->containsUnexpandedParameterPack()),
705     SubExpr(subexpr) {
706   ExprWithCleanupsBits.NumObjects = objects.size();
707   for (unsigned i = 0, e = objects.size(); i != e; ++i)
708     getObjectsBuffer()[i] = objects[i];
709 }
710 
711 ExprWithCleanups *ExprWithCleanups::Create(ASTContext &C, Expr *subexpr,
712                                            ArrayRef<CleanupObject> objects) {
713   size_t size = sizeof(ExprWithCleanups)
714               + objects.size() * sizeof(CleanupObject);
715   void *buffer = C.Allocate(size, llvm::alignOf<ExprWithCleanups>());
716   return new (buffer) ExprWithCleanups(subexpr, objects);
717 }
718 
719 ExprWithCleanups::ExprWithCleanups(EmptyShell empty, unsigned numObjects)
720   : Expr(ExprWithCleanupsClass, empty) {
721   ExprWithCleanupsBits.NumObjects = numObjects;
722 }
723 
724 ExprWithCleanups *ExprWithCleanups::Create(ASTContext &C, EmptyShell empty,
725                                            unsigned numObjects) {
726   size_t size = sizeof(ExprWithCleanups) + numObjects * sizeof(CleanupObject);
727   void *buffer = C.Allocate(size, llvm::alignOf<ExprWithCleanups>());
728   return new (buffer) ExprWithCleanups(empty, numObjects);
729 }
730 
731 CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(TypeSourceInfo *Type,
732                                                  SourceLocation LParenLoc,
733                                                  Expr **Args,
734                                                  unsigned NumArgs,
735                                                  SourceLocation RParenLoc)
736   : Expr(CXXUnresolvedConstructExprClass,
737          Type->getType().getNonReferenceType(),
738          (Type->getType()->isLValueReferenceType() ? VK_LValue
739           :Type->getType()->isRValueReferenceType()? VK_XValue
740           :VK_RValue),
741          OK_Ordinary,
742          Type->getType()->isDependentType(), true, true,
743          Type->getType()->containsUnexpandedParameterPack()),
744     Type(Type),
745     LParenLoc(LParenLoc),
746     RParenLoc(RParenLoc),
747     NumArgs(NumArgs) {
748   Stmt **StoredArgs = reinterpret_cast<Stmt **>(this + 1);
749   for (unsigned I = 0; I != NumArgs; ++I) {
750     if (Args[I]->containsUnexpandedParameterPack())
751       ExprBits.ContainsUnexpandedParameterPack = true;
752 
753     StoredArgs[I] = Args[I];
754   }
755 }
756 
757 CXXUnresolvedConstructExpr *
758 CXXUnresolvedConstructExpr::Create(ASTContext &C,
759                                    TypeSourceInfo *Type,
760                                    SourceLocation LParenLoc,
761                                    Expr **Args,
762                                    unsigned NumArgs,
763                                    SourceLocation RParenLoc) {
764   void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) +
765                          sizeof(Expr *) * NumArgs);
766   return new (Mem) CXXUnresolvedConstructExpr(Type, LParenLoc,
767                                               Args, NumArgs, RParenLoc);
768 }
769 
770 CXXUnresolvedConstructExpr *
771 CXXUnresolvedConstructExpr::CreateEmpty(ASTContext &C, unsigned NumArgs) {
772   Stmt::EmptyShell Empty;
773   void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) +
774                          sizeof(Expr *) * NumArgs);
775   return new (Mem) CXXUnresolvedConstructExpr(Empty, NumArgs);
776 }
777 
778 SourceRange CXXUnresolvedConstructExpr::getSourceRange() const {
779   return SourceRange(Type->getTypeLoc().getBeginLoc(), RParenLoc);
780 }
781 
782 CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C,
783                                                  Expr *Base, QualType BaseType,
784                                                  bool IsArrow,
785                                                  SourceLocation OperatorLoc,
786                                            NestedNameSpecifierLoc QualifierLoc,
787                                           NamedDecl *FirstQualifierFoundInScope,
788                                           DeclarationNameInfo MemberNameInfo,
789                                    const TemplateArgumentListInfo *TemplateArgs)
790   : Expr(CXXDependentScopeMemberExprClass, C.DependentTy,
791          VK_LValue, OK_Ordinary, true, true, true,
792          ((Base && Base->containsUnexpandedParameterPack()) ||
793           (QualifierLoc &&
794            QualifierLoc.getNestedNameSpecifier()
795                                        ->containsUnexpandedParameterPack()) ||
796           MemberNameInfo.containsUnexpandedParameterPack())),
797     Base(Base), BaseType(BaseType), IsArrow(IsArrow),
798     HasExplicitTemplateArgs(TemplateArgs != 0),
799     OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),
800     FirstQualifierFoundInScope(FirstQualifierFoundInScope),
801     MemberNameInfo(MemberNameInfo) {
802   if (TemplateArgs) {
803     bool Dependent = true;
804     bool InstantiationDependent = true;
805     bool ContainsUnexpandedParameterPack = false;
806     getExplicitTemplateArgs().initializeFrom(*TemplateArgs, Dependent,
807                                              InstantiationDependent,
808                                              ContainsUnexpandedParameterPack);
809     if (ContainsUnexpandedParameterPack)
810       ExprBits.ContainsUnexpandedParameterPack = true;
811   }
812 }
813 
814 CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C,
815                           Expr *Base, QualType BaseType,
816                           bool IsArrow,
817                           SourceLocation OperatorLoc,
818                           NestedNameSpecifierLoc QualifierLoc,
819                           NamedDecl *FirstQualifierFoundInScope,
820                           DeclarationNameInfo MemberNameInfo)
821   : Expr(CXXDependentScopeMemberExprClass, C.DependentTy,
822          VK_LValue, OK_Ordinary, true, true, true,
823          ((Base && Base->containsUnexpandedParameterPack()) ||
824           (QualifierLoc &&
825            QualifierLoc.getNestedNameSpecifier()->
826                                          containsUnexpandedParameterPack()) ||
827           MemberNameInfo.containsUnexpandedParameterPack())),
828     Base(Base), BaseType(BaseType), IsArrow(IsArrow),
829     HasExplicitTemplateArgs(false), OperatorLoc(OperatorLoc),
830     QualifierLoc(QualifierLoc),
831     FirstQualifierFoundInScope(FirstQualifierFoundInScope),
832     MemberNameInfo(MemberNameInfo) { }
833 
834 CXXDependentScopeMemberExpr *
835 CXXDependentScopeMemberExpr::Create(ASTContext &C,
836                                 Expr *Base, QualType BaseType, bool IsArrow,
837                                 SourceLocation OperatorLoc,
838                                 NestedNameSpecifierLoc QualifierLoc,
839                                 NamedDecl *FirstQualifierFoundInScope,
840                                 DeclarationNameInfo MemberNameInfo,
841                                 const TemplateArgumentListInfo *TemplateArgs) {
842   if (!TemplateArgs)
843     return new (C) CXXDependentScopeMemberExpr(C, Base, BaseType,
844                                                IsArrow, OperatorLoc,
845                                                QualifierLoc,
846                                                FirstQualifierFoundInScope,
847                                                MemberNameInfo);
848 
849   std::size_t size = sizeof(CXXDependentScopeMemberExpr);
850   if (TemplateArgs)
851     size += ASTTemplateArgumentListInfo::sizeFor(*TemplateArgs);
852 
853   void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>());
854   return new (Mem) CXXDependentScopeMemberExpr(C, Base, BaseType,
855                                                IsArrow, OperatorLoc,
856                                                QualifierLoc,
857                                                FirstQualifierFoundInScope,
858                                                MemberNameInfo, TemplateArgs);
859 }
860 
861 CXXDependentScopeMemberExpr *
862 CXXDependentScopeMemberExpr::CreateEmpty(ASTContext &C,
863                                          bool HasExplicitTemplateArgs,
864                                          unsigned NumTemplateArgs) {
865   if (!HasExplicitTemplateArgs)
866     return new (C) CXXDependentScopeMemberExpr(C, 0, QualType(),
867                                                0, SourceLocation(),
868                                                NestedNameSpecifierLoc(), 0,
869                                                DeclarationNameInfo());
870 
871   std::size_t size = sizeof(CXXDependentScopeMemberExpr) +
872                      ASTTemplateArgumentListInfo::sizeFor(NumTemplateArgs);
873   void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>());
874   CXXDependentScopeMemberExpr *E
875     =  new (Mem) CXXDependentScopeMemberExpr(C, 0, QualType(),
876                                              0, SourceLocation(),
877                                              NestedNameSpecifierLoc(), 0,
878                                              DeclarationNameInfo(), 0);
879   E->HasExplicitTemplateArgs = true;
880   return E;
881 }
882 
883 bool CXXDependentScopeMemberExpr::isImplicitAccess() const {
884   if (Base == 0)
885     return true;
886 
887   return cast<Expr>(Base)->isImplicitCXXThis();
888 }
889 
890 static bool hasOnlyNonStaticMemberFunctions(UnresolvedSetIterator begin,
891                                             UnresolvedSetIterator end) {
892   do {
893     NamedDecl *decl = *begin;
894     if (isa<UnresolvedUsingValueDecl>(decl))
895       return false;
896     if (isa<UsingShadowDecl>(decl))
897       decl = cast<UsingShadowDecl>(decl)->getUnderlyingDecl();
898 
899     // Unresolved member expressions should only contain methods and
900     // method templates.
901     assert(isa<CXXMethodDecl>(decl) || isa<FunctionTemplateDecl>(decl));
902 
903     if (isa<FunctionTemplateDecl>(decl))
904       decl = cast<FunctionTemplateDecl>(decl)->getTemplatedDecl();
905     if (cast<CXXMethodDecl>(decl)->isStatic())
906       return false;
907   } while (++begin != end);
908 
909   return true;
910 }
911 
912 UnresolvedMemberExpr::UnresolvedMemberExpr(ASTContext &C,
913                                            bool HasUnresolvedUsing,
914                                            Expr *Base, QualType BaseType,
915                                            bool IsArrow,
916                                            SourceLocation OperatorLoc,
917                                            NestedNameSpecifierLoc QualifierLoc,
918                                    const DeclarationNameInfo &MemberNameInfo,
919                                    const TemplateArgumentListInfo *TemplateArgs,
920                                            UnresolvedSetIterator Begin,
921                                            UnresolvedSetIterator End)
922   : OverloadExpr(UnresolvedMemberExprClass, C, QualifierLoc, MemberNameInfo,
923                  TemplateArgs, Begin, End,
924                  // Dependent
925                  ((Base && Base->isTypeDependent()) ||
926                   BaseType->isDependentType()),
927                  ((Base && Base->isInstantiationDependent()) ||
928                    BaseType->isInstantiationDependentType()),
929                  // Contains unexpanded parameter pack
930                  ((Base && Base->containsUnexpandedParameterPack()) ||
931                   BaseType->containsUnexpandedParameterPack())),
932     IsArrow(IsArrow), HasUnresolvedUsing(HasUnresolvedUsing),
933     Base(Base), BaseType(BaseType), OperatorLoc(OperatorLoc) {
934 
935   // Check whether all of the members are non-static member functions,
936   // and if so, mark give this bound-member type instead of overload type.
937   if (hasOnlyNonStaticMemberFunctions(Begin, End))
938     setType(C.BoundMemberTy);
939 }
940 
941 bool UnresolvedMemberExpr::isImplicitAccess() const {
942   if (Base == 0)
943     return true;
944 
945   return cast<Expr>(Base)->isImplicitCXXThis();
946 }
947 
948 UnresolvedMemberExpr *
949 UnresolvedMemberExpr::Create(ASTContext &C,
950                              bool HasUnresolvedUsing,
951                              Expr *Base, QualType BaseType, bool IsArrow,
952                              SourceLocation OperatorLoc,
953                              NestedNameSpecifierLoc QualifierLoc,
954                              const DeclarationNameInfo &MemberNameInfo,
955                              const TemplateArgumentListInfo *TemplateArgs,
956                              UnresolvedSetIterator Begin,
957                              UnresolvedSetIterator End) {
958   std::size_t size = sizeof(UnresolvedMemberExpr);
959   if (TemplateArgs)
960     size += ASTTemplateArgumentListInfo::sizeFor(*TemplateArgs);
961 
962   void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>());
963   return new (Mem) UnresolvedMemberExpr(C,
964                              HasUnresolvedUsing, Base, BaseType,
965                              IsArrow, OperatorLoc, QualifierLoc,
966                              MemberNameInfo, TemplateArgs, Begin, End);
967 }
968 
969 UnresolvedMemberExpr *
970 UnresolvedMemberExpr::CreateEmpty(ASTContext &C, bool HasExplicitTemplateArgs,
971                                   unsigned NumTemplateArgs) {
972   std::size_t size = sizeof(UnresolvedMemberExpr);
973   if (HasExplicitTemplateArgs)
974     size += ASTTemplateArgumentListInfo::sizeFor(NumTemplateArgs);
975 
976   void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>());
977   UnresolvedMemberExpr *E = new (Mem) UnresolvedMemberExpr(EmptyShell());
978   E->HasExplicitTemplateArgs = HasExplicitTemplateArgs;
979   return E;
980 }
981 
982 CXXRecordDecl *UnresolvedMemberExpr::getNamingClass() const {
983   // Unlike for UnresolvedLookupExpr, it is very easy to re-derive this.
984 
985   // If there was a nested name specifier, it names the naming class.
986   // It can't be dependent: after all, we were actually able to do the
987   // lookup.
988   CXXRecordDecl *Record = 0;
989   if (getQualifier()) {
990     const Type *T = getQualifier()->getAsType();
991     assert(T && "qualifier in member expression does not name type");
992     Record = T->getAsCXXRecordDecl();
993     assert(Record && "qualifier in member expression does not name record");
994   }
995   // Otherwise the naming class must have been the base class.
996   else {
997     QualType BaseType = getBaseType().getNonReferenceType();
998     if (isArrow()) {
999       const PointerType *PT = BaseType->getAs<PointerType>();
1000       assert(PT && "base of arrow member access is not pointer");
1001       BaseType = PT->getPointeeType();
1002     }
1003 
1004     Record = BaseType->getAsCXXRecordDecl();
1005     assert(Record && "base of member expression does not name record");
1006   }
1007 
1008   return Record;
1009 }
1010 
1011 SubstNonTypeTemplateParmPackExpr::
1012 SubstNonTypeTemplateParmPackExpr(QualType T,
1013                                  NonTypeTemplateParmDecl *Param,
1014                                  SourceLocation NameLoc,
1015                                  const TemplateArgument &ArgPack)
1016   : Expr(SubstNonTypeTemplateParmPackExprClass, T, VK_RValue, OK_Ordinary,
1017          true, true, true, true),
1018     Param(Param), Arguments(ArgPack.pack_begin()),
1019     NumArguments(ArgPack.pack_size()), NameLoc(NameLoc) { }
1020 
1021 TemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const {
1022   return TemplateArgument(Arguments, NumArguments);
1023 }
1024 
1025 
1026