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           SubExpr->getType()->isArrayType()) &&
623          "Expression bound to a temporary must have record or array type!");
624 
625   return new (C) CXXBindTemporaryExpr(Temp, SubExpr);
626 }
627 
628 CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(ASTContext &C,
629                                                CXXConstructorDecl *Cons,
630                                                TypeSourceInfo *Type,
631                                                Expr **Args,
632                                                unsigned NumArgs,
633                                                SourceRange parenRange,
634                                                bool HadMultipleCandidates,
635                                                bool ZeroInitialization)
636   : CXXConstructExpr(C, CXXTemporaryObjectExprClass,
637                      Type->getType().getNonReferenceType(),
638                      Type->getTypeLoc().getBeginLoc(),
639                      Cons, false, Args, NumArgs,
640                      HadMultipleCandidates, ZeroInitialization,
641                      CXXConstructExpr::CK_Complete, parenRange),
642     Type(Type) {
643 }
644 
645 SourceRange CXXTemporaryObjectExpr::getSourceRange() const {
646   return SourceRange(Type->getTypeLoc().getBeginLoc(),
647                      getParenRange().getEnd());
648 }
649 
650 CXXConstructExpr *CXXConstructExpr::Create(ASTContext &C, QualType T,
651                                            SourceLocation Loc,
652                                            CXXConstructorDecl *D, bool Elidable,
653                                            Expr **Args, unsigned NumArgs,
654                                            bool HadMultipleCandidates,
655                                            bool ZeroInitialization,
656                                            ConstructionKind ConstructKind,
657                                            SourceRange ParenRange) {
658   return new (C) CXXConstructExpr(C, CXXConstructExprClass, T, Loc, D,
659                                   Elidable, Args, NumArgs,
660                                   HadMultipleCandidates, ZeroInitialization,
661                                   ConstructKind, ParenRange);
662 }
663 
664 CXXConstructExpr::CXXConstructExpr(ASTContext &C, StmtClass SC, QualType T,
665                                    SourceLocation Loc,
666                                    CXXConstructorDecl *D, bool elidable,
667                                    Expr **args, unsigned numargs,
668                                    bool HadMultipleCandidates,
669                                    bool ZeroInitialization,
670                                    ConstructionKind ConstructKind,
671                                    SourceRange ParenRange)
672   : Expr(SC, T, VK_RValue, OK_Ordinary,
673          T->isDependentType(), T->isDependentType(),
674          T->isInstantiationDependentType(),
675          T->containsUnexpandedParameterPack()),
676     Constructor(D), Loc(Loc), ParenRange(ParenRange),  NumArgs(numargs),
677     Elidable(elidable), HadMultipleCandidates(HadMultipleCandidates),
678     ZeroInitialization(ZeroInitialization),
679     ConstructKind(ConstructKind), Args(0)
680 {
681   if (NumArgs) {
682     Args = new (C) Stmt*[NumArgs];
683 
684     for (unsigned i = 0; i != NumArgs; ++i) {
685       assert(args[i] && "NULL argument in CXXConstructExpr");
686 
687       if (args[i]->isValueDependent())
688         ExprBits.ValueDependent = true;
689       if (args[i]->isInstantiationDependent())
690         ExprBits.InstantiationDependent = true;
691       if (args[i]->containsUnexpandedParameterPack())
692         ExprBits.ContainsUnexpandedParameterPack = true;
693 
694       Args[i] = args[i];
695     }
696   }
697 }
698 
699 ExprWithCleanups::ExprWithCleanups(Expr *subexpr,
700                                    ArrayRef<CleanupObject> objects)
701   : Expr(ExprWithCleanupsClass, subexpr->getType(),
702          subexpr->getValueKind(), subexpr->getObjectKind(),
703          subexpr->isTypeDependent(), subexpr->isValueDependent(),
704          subexpr->isInstantiationDependent(),
705          subexpr->containsUnexpandedParameterPack()),
706     SubExpr(subexpr) {
707   ExprWithCleanupsBits.NumObjects = objects.size();
708   for (unsigned i = 0, e = objects.size(); i != e; ++i)
709     getObjectsBuffer()[i] = objects[i];
710 }
711 
712 ExprWithCleanups *ExprWithCleanups::Create(ASTContext &C, Expr *subexpr,
713                                            ArrayRef<CleanupObject> objects) {
714   size_t size = sizeof(ExprWithCleanups)
715               + objects.size() * sizeof(CleanupObject);
716   void *buffer = C.Allocate(size, llvm::alignOf<ExprWithCleanups>());
717   return new (buffer) ExprWithCleanups(subexpr, objects);
718 }
719 
720 ExprWithCleanups::ExprWithCleanups(EmptyShell empty, unsigned numObjects)
721   : Expr(ExprWithCleanupsClass, empty) {
722   ExprWithCleanupsBits.NumObjects = numObjects;
723 }
724 
725 ExprWithCleanups *ExprWithCleanups::Create(ASTContext &C, EmptyShell empty,
726                                            unsigned numObjects) {
727   size_t size = sizeof(ExprWithCleanups) + numObjects * sizeof(CleanupObject);
728   void *buffer = C.Allocate(size, llvm::alignOf<ExprWithCleanups>());
729   return new (buffer) ExprWithCleanups(empty, numObjects);
730 }
731 
732 CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(TypeSourceInfo *Type,
733                                                  SourceLocation LParenLoc,
734                                                  Expr **Args,
735                                                  unsigned NumArgs,
736                                                  SourceLocation RParenLoc)
737   : Expr(CXXUnresolvedConstructExprClass,
738          Type->getType().getNonReferenceType(),
739          (Type->getType()->isLValueReferenceType() ? VK_LValue
740           :Type->getType()->isRValueReferenceType()? VK_XValue
741           :VK_RValue),
742          OK_Ordinary,
743          Type->getType()->isDependentType(), true, true,
744          Type->getType()->containsUnexpandedParameterPack()),
745     Type(Type),
746     LParenLoc(LParenLoc),
747     RParenLoc(RParenLoc),
748     NumArgs(NumArgs) {
749   Stmt **StoredArgs = reinterpret_cast<Stmt **>(this + 1);
750   for (unsigned I = 0; I != NumArgs; ++I) {
751     if (Args[I]->containsUnexpandedParameterPack())
752       ExprBits.ContainsUnexpandedParameterPack = true;
753 
754     StoredArgs[I] = Args[I];
755   }
756 }
757 
758 CXXUnresolvedConstructExpr *
759 CXXUnresolvedConstructExpr::Create(ASTContext &C,
760                                    TypeSourceInfo *Type,
761                                    SourceLocation LParenLoc,
762                                    Expr **Args,
763                                    unsigned NumArgs,
764                                    SourceLocation RParenLoc) {
765   void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) +
766                          sizeof(Expr *) * NumArgs);
767   return new (Mem) CXXUnresolvedConstructExpr(Type, LParenLoc,
768                                               Args, NumArgs, RParenLoc);
769 }
770 
771 CXXUnresolvedConstructExpr *
772 CXXUnresolvedConstructExpr::CreateEmpty(ASTContext &C, unsigned NumArgs) {
773   Stmt::EmptyShell Empty;
774   void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) +
775                          sizeof(Expr *) * NumArgs);
776   return new (Mem) CXXUnresolvedConstructExpr(Empty, NumArgs);
777 }
778 
779 SourceRange CXXUnresolvedConstructExpr::getSourceRange() const {
780   return SourceRange(Type->getTypeLoc().getBeginLoc(), RParenLoc);
781 }
782 
783 CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C,
784                                                  Expr *Base, QualType BaseType,
785                                                  bool IsArrow,
786                                                  SourceLocation OperatorLoc,
787                                            NestedNameSpecifierLoc QualifierLoc,
788                                           NamedDecl *FirstQualifierFoundInScope,
789                                           DeclarationNameInfo MemberNameInfo,
790                                    const TemplateArgumentListInfo *TemplateArgs)
791   : Expr(CXXDependentScopeMemberExprClass, C.DependentTy,
792          VK_LValue, OK_Ordinary, true, true, true,
793          ((Base && Base->containsUnexpandedParameterPack()) ||
794           (QualifierLoc &&
795            QualifierLoc.getNestedNameSpecifier()
796                                        ->containsUnexpandedParameterPack()) ||
797           MemberNameInfo.containsUnexpandedParameterPack())),
798     Base(Base), BaseType(BaseType), IsArrow(IsArrow),
799     HasExplicitTemplateArgs(TemplateArgs != 0),
800     OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),
801     FirstQualifierFoundInScope(FirstQualifierFoundInScope),
802     MemberNameInfo(MemberNameInfo) {
803   if (TemplateArgs) {
804     bool Dependent = true;
805     bool InstantiationDependent = true;
806     bool ContainsUnexpandedParameterPack = false;
807     getExplicitTemplateArgs().initializeFrom(*TemplateArgs, Dependent,
808                                              InstantiationDependent,
809                                              ContainsUnexpandedParameterPack);
810     if (ContainsUnexpandedParameterPack)
811       ExprBits.ContainsUnexpandedParameterPack = true;
812   }
813 }
814 
815 CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C,
816                           Expr *Base, QualType BaseType,
817                           bool IsArrow,
818                           SourceLocation OperatorLoc,
819                           NestedNameSpecifierLoc QualifierLoc,
820                           NamedDecl *FirstQualifierFoundInScope,
821                           DeclarationNameInfo MemberNameInfo)
822   : Expr(CXXDependentScopeMemberExprClass, C.DependentTy,
823          VK_LValue, OK_Ordinary, true, true, true,
824          ((Base && Base->containsUnexpandedParameterPack()) ||
825           (QualifierLoc &&
826            QualifierLoc.getNestedNameSpecifier()->
827                                          containsUnexpandedParameterPack()) ||
828           MemberNameInfo.containsUnexpandedParameterPack())),
829     Base(Base), BaseType(BaseType), IsArrow(IsArrow),
830     HasExplicitTemplateArgs(false), OperatorLoc(OperatorLoc),
831     QualifierLoc(QualifierLoc),
832     FirstQualifierFoundInScope(FirstQualifierFoundInScope),
833     MemberNameInfo(MemberNameInfo) { }
834 
835 CXXDependentScopeMemberExpr *
836 CXXDependentScopeMemberExpr::Create(ASTContext &C,
837                                 Expr *Base, QualType BaseType, bool IsArrow,
838                                 SourceLocation OperatorLoc,
839                                 NestedNameSpecifierLoc QualifierLoc,
840                                 NamedDecl *FirstQualifierFoundInScope,
841                                 DeclarationNameInfo MemberNameInfo,
842                                 const TemplateArgumentListInfo *TemplateArgs) {
843   if (!TemplateArgs)
844     return new (C) CXXDependentScopeMemberExpr(C, Base, BaseType,
845                                                IsArrow, OperatorLoc,
846                                                QualifierLoc,
847                                                FirstQualifierFoundInScope,
848                                                MemberNameInfo);
849 
850   std::size_t size = sizeof(CXXDependentScopeMemberExpr);
851   if (TemplateArgs)
852     size += ASTTemplateArgumentListInfo::sizeFor(*TemplateArgs);
853 
854   void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>());
855   return new (Mem) CXXDependentScopeMemberExpr(C, Base, BaseType,
856                                                IsArrow, OperatorLoc,
857                                                QualifierLoc,
858                                                FirstQualifierFoundInScope,
859                                                MemberNameInfo, TemplateArgs);
860 }
861 
862 CXXDependentScopeMemberExpr *
863 CXXDependentScopeMemberExpr::CreateEmpty(ASTContext &C,
864                                          bool HasExplicitTemplateArgs,
865                                          unsigned NumTemplateArgs) {
866   if (!HasExplicitTemplateArgs)
867     return new (C) CXXDependentScopeMemberExpr(C, 0, QualType(),
868                                                0, SourceLocation(),
869                                                NestedNameSpecifierLoc(), 0,
870                                                DeclarationNameInfo());
871 
872   std::size_t size = sizeof(CXXDependentScopeMemberExpr) +
873                      ASTTemplateArgumentListInfo::sizeFor(NumTemplateArgs);
874   void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>());
875   CXXDependentScopeMemberExpr *E
876     =  new (Mem) CXXDependentScopeMemberExpr(C, 0, QualType(),
877                                              0, SourceLocation(),
878                                              NestedNameSpecifierLoc(), 0,
879                                              DeclarationNameInfo(), 0);
880   E->HasExplicitTemplateArgs = true;
881   return E;
882 }
883 
884 bool CXXDependentScopeMemberExpr::isImplicitAccess() const {
885   if (Base == 0)
886     return true;
887 
888   return cast<Expr>(Base)->isImplicitCXXThis();
889 }
890 
891 static bool hasOnlyNonStaticMemberFunctions(UnresolvedSetIterator begin,
892                                             UnresolvedSetIterator end) {
893   do {
894     NamedDecl *decl = *begin;
895     if (isa<UnresolvedUsingValueDecl>(decl))
896       return false;
897     if (isa<UsingShadowDecl>(decl))
898       decl = cast<UsingShadowDecl>(decl)->getUnderlyingDecl();
899 
900     // Unresolved member expressions should only contain methods and
901     // method templates.
902     assert(isa<CXXMethodDecl>(decl) || isa<FunctionTemplateDecl>(decl));
903 
904     if (isa<FunctionTemplateDecl>(decl))
905       decl = cast<FunctionTemplateDecl>(decl)->getTemplatedDecl();
906     if (cast<CXXMethodDecl>(decl)->isStatic())
907       return false;
908   } while (++begin != end);
909 
910   return true;
911 }
912 
913 UnresolvedMemberExpr::UnresolvedMemberExpr(ASTContext &C,
914                                            bool HasUnresolvedUsing,
915                                            Expr *Base, QualType BaseType,
916                                            bool IsArrow,
917                                            SourceLocation OperatorLoc,
918                                            NestedNameSpecifierLoc QualifierLoc,
919                                    const DeclarationNameInfo &MemberNameInfo,
920                                    const TemplateArgumentListInfo *TemplateArgs,
921                                            UnresolvedSetIterator Begin,
922                                            UnresolvedSetIterator End)
923   : OverloadExpr(UnresolvedMemberExprClass, C, QualifierLoc, MemberNameInfo,
924                  TemplateArgs, Begin, End,
925                  // Dependent
926                  ((Base && Base->isTypeDependent()) ||
927                   BaseType->isDependentType()),
928                  ((Base && Base->isInstantiationDependent()) ||
929                    BaseType->isInstantiationDependentType()),
930                  // Contains unexpanded parameter pack
931                  ((Base && Base->containsUnexpandedParameterPack()) ||
932                   BaseType->containsUnexpandedParameterPack())),
933     IsArrow(IsArrow), HasUnresolvedUsing(HasUnresolvedUsing),
934     Base(Base), BaseType(BaseType), OperatorLoc(OperatorLoc) {
935 
936   // Check whether all of the members are non-static member functions,
937   // and if so, mark give this bound-member type instead of overload type.
938   if (hasOnlyNonStaticMemberFunctions(Begin, End))
939     setType(C.BoundMemberTy);
940 }
941 
942 bool UnresolvedMemberExpr::isImplicitAccess() const {
943   if (Base == 0)
944     return true;
945 
946   return cast<Expr>(Base)->isImplicitCXXThis();
947 }
948 
949 UnresolvedMemberExpr *
950 UnresolvedMemberExpr::Create(ASTContext &C,
951                              bool HasUnresolvedUsing,
952                              Expr *Base, QualType BaseType, bool IsArrow,
953                              SourceLocation OperatorLoc,
954                              NestedNameSpecifierLoc QualifierLoc,
955                              const DeclarationNameInfo &MemberNameInfo,
956                              const TemplateArgumentListInfo *TemplateArgs,
957                              UnresolvedSetIterator Begin,
958                              UnresolvedSetIterator End) {
959   std::size_t size = sizeof(UnresolvedMemberExpr);
960   if (TemplateArgs)
961     size += ASTTemplateArgumentListInfo::sizeFor(*TemplateArgs);
962 
963   void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>());
964   return new (Mem) UnresolvedMemberExpr(C,
965                              HasUnresolvedUsing, Base, BaseType,
966                              IsArrow, OperatorLoc, QualifierLoc,
967                              MemberNameInfo, TemplateArgs, Begin, End);
968 }
969 
970 UnresolvedMemberExpr *
971 UnresolvedMemberExpr::CreateEmpty(ASTContext &C, bool HasExplicitTemplateArgs,
972                                   unsigned NumTemplateArgs) {
973   std::size_t size = sizeof(UnresolvedMemberExpr);
974   if (HasExplicitTemplateArgs)
975     size += ASTTemplateArgumentListInfo::sizeFor(NumTemplateArgs);
976 
977   void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>());
978   UnresolvedMemberExpr *E = new (Mem) UnresolvedMemberExpr(EmptyShell());
979   E->HasExplicitTemplateArgs = HasExplicitTemplateArgs;
980   return E;
981 }
982 
983 CXXRecordDecl *UnresolvedMemberExpr::getNamingClass() const {
984   // Unlike for UnresolvedLookupExpr, it is very easy to re-derive this.
985 
986   // If there was a nested name specifier, it names the naming class.
987   // It can't be dependent: after all, we were actually able to do the
988   // lookup.
989   CXXRecordDecl *Record = 0;
990   if (getQualifier()) {
991     const Type *T = getQualifier()->getAsType();
992     assert(T && "qualifier in member expression does not name type");
993     Record = T->getAsCXXRecordDecl();
994     assert(Record && "qualifier in member expression does not name record");
995   }
996   // Otherwise the naming class must have been the base class.
997   else {
998     QualType BaseType = getBaseType().getNonReferenceType();
999     if (isArrow()) {
1000       const PointerType *PT = BaseType->getAs<PointerType>();
1001       assert(PT && "base of arrow member access is not pointer");
1002       BaseType = PT->getPointeeType();
1003     }
1004 
1005     Record = BaseType->getAsCXXRecordDecl();
1006     assert(Record && "base of member expression does not name record");
1007   }
1008 
1009   return Record;
1010 }
1011 
1012 SubstNonTypeTemplateParmPackExpr::
1013 SubstNonTypeTemplateParmPackExpr(QualType T,
1014                                  NonTypeTemplateParmDecl *Param,
1015                                  SourceLocation NameLoc,
1016                                  const TemplateArgument &ArgPack)
1017   : Expr(SubstNonTypeTemplateParmPackExprClass, T, VK_RValue, OK_Ordinary,
1018          true, true, true, true),
1019     Param(Param), Arguments(ArgPack.pack_begin()),
1020     NumArguments(ArgPack.pack_size()), NameLoc(NameLoc) { }
1021 
1022 TemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const {
1023   return TemplateArgument(Arguments, NumArguments);
1024 }
1025 
1026 void ArrayTypeTraitExpr::anchor() { }
1027