ExprCXX.cpp revision 234353 
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"
19using namespace clang;
20
21
22//===----------------------------------------------------------------------===//
23//  Child Iterators for iterating over subexpressions/substatements
24//===----------------------------------------------------------------------===//
25
26QualType CXXTypeidExpr::getTypeOperand() const {
27  assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)");
28  return Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType()
29                                                        .getUnqualifiedType();
30}
31
32QualType 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
39SourceRange CXXScalarValueInitExpr::getSourceRange() const {
40  SourceLocation Start = RParenLoc;
41  if (TypeInfo)
42    Start = TypeInfo->getTypeLoc().getBeginLoc();
43  return SourceRange(Start, RParenLoc);
44}
45
46// CXXNewExpr
47CXXNewExpr::CXXNewExpr(ASTContext &C, bool globalNew, FunctionDecl *operatorNew,
48                       FunctionDecl *operatorDelete,
49                       bool usualArrayDeleteWantsSize,
50                       Expr **placementArgs, unsigned numPlaceArgs,
51                       SourceRange typeIdParens, Expr *arraySize,
52                       InitializationStyle initializationStyle,
53                       Expr *initializer, QualType ty,
54                       TypeSourceInfo *allocatedTypeInfo,
55                       SourceLocation startLoc, SourceRange directInitRange)
56  : Expr(CXXNewExprClass, ty, VK_RValue, OK_Ordinary,
57         ty->isDependentType(), ty->isDependentType(),
58         ty->isInstantiationDependentType(),
59         ty->containsUnexpandedParameterPack()),
60    SubExprs(0), OperatorNew(operatorNew), OperatorDelete(operatorDelete),
61    AllocatedTypeInfo(allocatedTypeInfo), TypeIdParens(typeIdParens),
62    StartLoc(startLoc), DirectInitRange(directInitRange),
63    GlobalNew(globalNew), UsualArrayDeleteWantsSize(usualArrayDeleteWantsSize) {
64  assert((initializer != 0 || initializationStyle == NoInit) &&
65         "Only NoInit can have no initializer.");
66  StoredInitializationStyle = initializer ? initializationStyle + 1 : 0;
67  AllocateArgsArray(C, arraySize != 0, numPlaceArgs, initializer != 0);
68  unsigned i = 0;
69  if (Array) {
70    if (arraySize->isInstantiationDependent())
71      ExprBits.InstantiationDependent = true;
72
73    if (arraySize->containsUnexpandedParameterPack())
74      ExprBits.ContainsUnexpandedParameterPack = true;
75
76    SubExprs[i++] = arraySize;
77  }
78
79  if (initializer) {
80    if (initializer->isInstantiationDependent())
81      ExprBits.InstantiationDependent = true;
82
83    if (initializer->containsUnexpandedParameterPack())
84      ExprBits.ContainsUnexpandedParameterPack = true;
85
86    SubExprs[i++] = initializer;
87  }
88
89  for (unsigned j = 0; j < NumPlacementArgs; ++j) {
90    if (placementArgs[j]->isInstantiationDependent())
91      ExprBits.InstantiationDependent = true;
92    if (placementArgs[j]->containsUnexpandedParameterPack())
93      ExprBits.ContainsUnexpandedParameterPack = true;
94
95    SubExprs[i++] = placementArgs[j];
96  }
97}
98
99void CXXNewExpr::AllocateArgsArray(ASTContext &C, bool isArray,
100                                   unsigned numPlaceArgs, bool hasInitializer){
101  assert(SubExprs == 0 && "SubExprs already allocated");
102  Array = isArray;
103  NumPlacementArgs = numPlaceArgs;
104
105  unsigned TotalSize = Array + hasInitializer + NumPlacementArgs;
106  SubExprs = new (C) Stmt*[TotalSize];
107}
108
109bool CXXNewExpr::shouldNullCheckAllocation(ASTContext &Ctx) const {
110  return getOperatorNew()->getType()->
111    castAs<FunctionProtoType>()->isNothrow(Ctx);
112}
113
114SourceLocation CXXNewExpr::getEndLoc() const {
115  switch (getInitializationStyle()) {
116  case NoInit:
117    return AllocatedTypeInfo->getTypeLoc().getEndLoc();
118  case CallInit:
119    return DirectInitRange.getEnd();
120  case ListInit:
121    return getInitializer()->getSourceRange().getEnd();
122  }
123  llvm_unreachable("bogus initialization style");
124}
125
126// CXXDeleteExpr
127QualType CXXDeleteExpr::getDestroyedType() const {
128  const Expr *Arg = getArgument();
129  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
130    if (ICE->getCastKind() != CK_UserDefinedConversion &&
131        ICE->getType()->isVoidPointerType())
132      Arg = ICE->getSubExpr();
133    else
134      break;
135  }
136  // The type-to-delete may not be a pointer if it's a dependent type.
137  const QualType ArgType = Arg->getType();
138
139  if (ArgType->isDependentType() && !ArgType->isPointerType())
140    return QualType();
141
142  return ArgType->getAs<PointerType>()->getPointeeType();
143}
144
145// CXXPseudoDestructorExpr
146PseudoDestructorTypeStorage::PseudoDestructorTypeStorage(TypeSourceInfo *Info)
147 : Type(Info)
148{
149  Location = Info->getTypeLoc().getLocalSourceRange().getBegin();
150}
151
152CXXPseudoDestructorExpr::CXXPseudoDestructorExpr(ASTContext &Context,
153                Expr *Base, bool isArrow, SourceLocation OperatorLoc,
154                NestedNameSpecifierLoc QualifierLoc, TypeSourceInfo *ScopeType,
155                SourceLocation ColonColonLoc, SourceLocation TildeLoc,
156                PseudoDestructorTypeStorage DestroyedType)
157  : Expr(CXXPseudoDestructorExprClass,
158         Context.getPointerType(Context.getFunctionType(Context.VoidTy, 0, 0,
159                                         FunctionProtoType::ExtProtoInfo())),
160         VK_RValue, OK_Ordinary,
161         /*isTypeDependent=*/(Base->isTypeDependent() ||
162           (DestroyedType.getTypeSourceInfo() &&
163            DestroyedType.getTypeSourceInfo()->getType()->isDependentType())),
164         /*isValueDependent=*/Base->isValueDependent(),
165         (Base->isInstantiationDependent() ||
166          (QualifierLoc &&
167           QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent()) ||
168          (ScopeType &&
169           ScopeType->getType()->isInstantiationDependentType()) ||
170          (DestroyedType.getTypeSourceInfo() &&
171           DestroyedType.getTypeSourceInfo()->getType()
172                                             ->isInstantiationDependentType())),
173         // ContainsUnexpandedParameterPack
174         (Base->containsUnexpandedParameterPack() ||
175          (QualifierLoc &&
176           QualifierLoc.getNestedNameSpecifier()
177                                        ->containsUnexpandedParameterPack()) ||
178          (ScopeType &&
179           ScopeType->getType()->containsUnexpandedParameterPack()) ||
180          (DestroyedType.getTypeSourceInfo() &&
181           DestroyedType.getTypeSourceInfo()->getType()
182                                   ->containsUnexpandedParameterPack()))),
183    Base(static_cast<Stmt *>(Base)), IsArrow(isArrow),
184    OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),
185    ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc),
186    DestroyedType(DestroyedType) { }
187
188QualType CXXPseudoDestructorExpr::getDestroyedType() const {
189  if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())
190    return TInfo->getType();
191
192  return QualType();
193}
194
195SourceRange CXXPseudoDestructorExpr::getSourceRange() const {
196  SourceLocation End = DestroyedType.getLocation();
197  if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())
198    End = TInfo->getTypeLoc().getLocalSourceRange().getEnd();
199  return SourceRange(Base->getLocStart(), End);
200}
201
202// UnresolvedLookupExpr
203UnresolvedLookupExpr *
204UnresolvedLookupExpr::Create(ASTContext &C,
205                             CXXRecordDecl *NamingClass,
206                             NestedNameSpecifierLoc QualifierLoc,
207                             SourceLocation TemplateKWLoc,
208                             const DeclarationNameInfo &NameInfo,
209                             bool ADL,
210                             const TemplateArgumentListInfo *Args,
211                             UnresolvedSetIterator Begin,
212                             UnresolvedSetIterator End)
213{
214  assert(Args || TemplateKWLoc.isValid());
215  unsigned num_args = Args ? Args->size() : 0;
216  void *Mem = C.Allocate(sizeof(UnresolvedLookupExpr) +
217                         ASTTemplateKWAndArgsInfo::sizeFor(num_args));
218  return new (Mem) UnresolvedLookupExpr(C, NamingClass, QualifierLoc,
219                                        TemplateKWLoc, NameInfo,
220                                        ADL, /*Overload*/ true, Args,
221                                        Begin, End, /*StdIsAssociated=*/false);
222}
223
224UnresolvedLookupExpr *
225UnresolvedLookupExpr::CreateEmpty(ASTContext &C,
226                                  bool HasTemplateKWAndArgsInfo,
227                                  unsigned NumTemplateArgs) {
228  std::size_t size = sizeof(UnresolvedLookupExpr);
229  if (HasTemplateKWAndArgsInfo)
230    size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs);
231
232  void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedLookupExpr>());
233  UnresolvedLookupExpr *E = new (Mem) UnresolvedLookupExpr(EmptyShell());
234  E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo;
235  return E;
236}
237
238OverloadExpr::OverloadExpr(StmtClass K, ASTContext &C,
239                           NestedNameSpecifierLoc QualifierLoc,
240                           SourceLocation TemplateKWLoc,
241                           const DeclarationNameInfo &NameInfo,
242                           const TemplateArgumentListInfo *TemplateArgs,
243                           UnresolvedSetIterator Begin,
244                           UnresolvedSetIterator End,
245                           bool KnownDependent,
246                           bool KnownInstantiationDependent,
247                           bool KnownContainsUnexpandedParameterPack)
248  : Expr(K, C.OverloadTy, VK_LValue, OK_Ordinary, KnownDependent,
249         KnownDependent,
250         (KnownInstantiationDependent ||
251          NameInfo.isInstantiationDependent() ||
252          (QualifierLoc &&
253           QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())),
254         (KnownContainsUnexpandedParameterPack ||
255          NameInfo.containsUnexpandedParameterPack() ||
256          (QualifierLoc &&
257           QualifierLoc.getNestedNameSpecifier()
258                                      ->containsUnexpandedParameterPack()))),
259    NameInfo(NameInfo), QualifierLoc(QualifierLoc),
260    Results(0), NumResults(End - Begin),
261    HasTemplateKWAndArgsInfo(TemplateArgs != 0 || TemplateKWLoc.isValid())
262{
263  NumResults = End - Begin;
264  if (NumResults) {
265    // Determine whether this expression is type-dependent.
266    for (UnresolvedSetImpl::const_iterator I = Begin; I != End; ++I) {
267      if ((*I)->getDeclContext()->isDependentContext() ||
268          isa<UnresolvedUsingValueDecl>(*I)) {
269        ExprBits.TypeDependent = true;
270        ExprBits.ValueDependent = true;
271      }
272    }
273
274    Results = static_cast<DeclAccessPair *>(
275                                C.Allocate(sizeof(DeclAccessPair) * NumResults,
276                                           llvm::alignOf<DeclAccessPair>()));
277    memcpy(Results, &*Begin.getIterator(),
278           NumResults * sizeof(DeclAccessPair));
279  }
280
281  // If we have explicit template arguments, check for dependent
282  // template arguments and whether they contain any unexpanded pack
283  // expansions.
284  if (TemplateArgs) {
285    bool Dependent = false;
286    bool InstantiationDependent = false;
287    bool ContainsUnexpandedParameterPack = false;
288    getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *TemplateArgs,
289                                               Dependent,
290                                               InstantiationDependent,
291                                               ContainsUnexpandedParameterPack);
292
293    if (Dependent) {
294      ExprBits.TypeDependent = true;
295      ExprBits.ValueDependent = true;
296    }
297    if (InstantiationDependent)
298      ExprBits.InstantiationDependent = true;
299    if (ContainsUnexpandedParameterPack)
300      ExprBits.ContainsUnexpandedParameterPack = true;
301  } else if (TemplateKWLoc.isValid()) {
302    getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc);
303  }
304
305  if (isTypeDependent())
306    setType(C.DependentTy);
307}
308
309void OverloadExpr::initializeResults(ASTContext &C,
310                                     UnresolvedSetIterator Begin,
311                                     UnresolvedSetIterator End) {
312  assert(Results == 0 && "Results already initialized!");
313  NumResults = End - Begin;
314  if (NumResults) {
315     Results = static_cast<DeclAccessPair *>(
316                               C.Allocate(sizeof(DeclAccessPair) * NumResults,
317
318                                          llvm::alignOf<DeclAccessPair>()));
319     memcpy(Results, &*Begin.getIterator(),
320            NumResults * sizeof(DeclAccessPair));
321  }
322}
323
324CXXRecordDecl *OverloadExpr::getNamingClass() const {
325  if (isa<UnresolvedLookupExpr>(this))
326    return cast<UnresolvedLookupExpr>(this)->getNamingClass();
327  else
328    return cast<UnresolvedMemberExpr>(this)->getNamingClass();
329}
330
331// DependentScopeDeclRefExpr
332DependentScopeDeclRefExpr::DependentScopeDeclRefExpr(QualType T,
333                            NestedNameSpecifierLoc QualifierLoc,
334                            SourceLocation TemplateKWLoc,
335                            const DeclarationNameInfo &NameInfo,
336                            const TemplateArgumentListInfo *Args)
337  : Expr(DependentScopeDeclRefExprClass, T, VK_LValue, OK_Ordinary,
338         true, true,
339         (NameInfo.isInstantiationDependent() ||
340          (QualifierLoc &&
341           QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())),
342         (NameInfo.containsUnexpandedParameterPack() ||
343          (QualifierLoc &&
344           QualifierLoc.getNestedNameSpecifier()
345                            ->containsUnexpandedParameterPack()))),
346    QualifierLoc(QualifierLoc), NameInfo(NameInfo),
347    HasTemplateKWAndArgsInfo(Args != 0 || TemplateKWLoc.isValid())
348{
349  if (Args) {
350    bool Dependent = true;
351    bool InstantiationDependent = true;
352    bool ContainsUnexpandedParameterPack
353      = ExprBits.ContainsUnexpandedParameterPack;
354    getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *Args,
355                                               Dependent,
356                                               InstantiationDependent,
357                                               ContainsUnexpandedParameterPack);
358    ExprBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack;
359  } else if (TemplateKWLoc.isValid()) {
360    getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc);
361  }
362}
363
364DependentScopeDeclRefExpr *
365DependentScopeDeclRefExpr::Create(ASTContext &C,
366                                  NestedNameSpecifierLoc QualifierLoc,
367                                  SourceLocation TemplateKWLoc,
368                                  const DeclarationNameInfo &NameInfo,
369                                  const TemplateArgumentListInfo *Args) {
370  std::size_t size = sizeof(DependentScopeDeclRefExpr);
371  if (Args)
372    size += ASTTemplateKWAndArgsInfo::sizeFor(Args->size());
373  else if (TemplateKWLoc.isValid())
374    size += ASTTemplateKWAndArgsInfo::sizeFor(0);
375  void *Mem = C.Allocate(size);
376  return new (Mem) DependentScopeDeclRefExpr(C.DependentTy, QualifierLoc,
377                                             TemplateKWLoc, NameInfo, Args);
378}
379
380DependentScopeDeclRefExpr *
381DependentScopeDeclRefExpr::CreateEmpty(ASTContext &C,
382                                       bool HasTemplateKWAndArgsInfo,
383                                       unsigned NumTemplateArgs) {
384  std::size_t size = sizeof(DependentScopeDeclRefExpr);
385  if (HasTemplateKWAndArgsInfo)
386    size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs);
387  void *Mem = C.Allocate(size);
388  DependentScopeDeclRefExpr *E
389    = new (Mem) DependentScopeDeclRefExpr(QualType(), NestedNameSpecifierLoc(),
390                                          SourceLocation(),
391                                          DeclarationNameInfo(), 0);
392  E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo;
393  return E;
394}
395
396SourceRange CXXConstructExpr::getSourceRange() const {
397  if (isa<CXXTemporaryObjectExpr>(this))
398    return cast<CXXTemporaryObjectExpr>(this)->getSourceRange();
399
400  if (ParenRange.isValid())
401    return SourceRange(Loc, ParenRange.getEnd());
402
403  SourceLocation End = Loc;
404  for (unsigned I = getNumArgs(); I > 0; --I) {
405    const Expr *Arg = getArg(I-1);
406    if (!Arg->isDefaultArgument()) {
407      SourceLocation NewEnd = Arg->getLocEnd();
408      if (NewEnd.isValid()) {
409        End = NewEnd;
410        break;
411      }
412    }
413  }
414
415  return SourceRange(Loc, End);
416}
417
418SourceRange CXXOperatorCallExpr::getSourceRange() const {
419  OverloadedOperatorKind Kind = getOperator();
420  if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
421    if (getNumArgs() == 1)
422      // Prefix operator
423      return SourceRange(getOperatorLoc(),
424                         getArg(0)->getSourceRange().getEnd());
425    else
426      // Postfix operator
427      return SourceRange(getArg(0)->getSourceRange().getBegin(),
428                         getOperatorLoc());
429  } else if (Kind == OO_Arrow) {
430    return getArg(0)->getSourceRange();
431  } else if (Kind == OO_Call) {
432    return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc());
433  } else if (Kind == OO_Subscript) {
434    return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc());
435  } else if (getNumArgs() == 1) {
436    return SourceRange(getOperatorLoc(), getArg(0)->getSourceRange().getEnd());
437  } else if (getNumArgs() == 2) {
438    return SourceRange(getArg(0)->getSourceRange().getBegin(),
439                       getArg(1)->getSourceRange().getEnd());
440  } else {
441    return SourceRange();
442  }
443}
444
445Expr *CXXMemberCallExpr::getImplicitObjectArgument() const {
446  if (const MemberExpr *MemExpr =
447        dyn_cast<MemberExpr>(getCallee()->IgnoreParens()))
448    return MemExpr->getBase();
449
450  // FIXME: Will eventually need to cope with member pointers.
451  return 0;
452}
453
454CXXMethodDecl *CXXMemberCallExpr::getMethodDecl() const {
455  if (const MemberExpr *MemExpr =
456      dyn_cast<MemberExpr>(getCallee()->IgnoreParens()))
457    return cast<CXXMethodDecl>(MemExpr->getMemberDecl());
458
459  // FIXME: Will eventually need to cope with member pointers.
460  return 0;
461}
462
463
464CXXRecordDecl *CXXMemberCallExpr::getRecordDecl() {
465  Expr* ThisArg = getImplicitObjectArgument();
466  if (!ThisArg)
467    return 0;
468
469  if (ThisArg->getType()->isAnyPointerType())
470    return ThisArg->getType()->getPointeeType()->getAsCXXRecordDecl();
471
472  return ThisArg->getType()->getAsCXXRecordDecl();
473}
474
475
476//===----------------------------------------------------------------------===//
477//  Named casts
478//===----------------------------------------------------------------------===//
479
480/// getCastName - Get the name of the C++ cast being used, e.g.,
481/// "static_cast", "dynamic_cast", "reinterpret_cast", or
482/// "const_cast". The returned pointer must not be freed.
483const char *CXXNamedCastExpr::getCastName() const {
484  switch (getStmtClass()) {
485  case CXXStaticCastExprClass:      return "static_cast";
486  case CXXDynamicCastExprClass:     return "dynamic_cast";
487  case CXXReinterpretCastExprClass: return "reinterpret_cast";
488  case CXXConstCastExprClass:       return "const_cast";
489  default:                          return "<invalid cast>";
490  }
491}
492
493CXXStaticCastExpr *CXXStaticCastExpr::Create(ASTContext &C, QualType T,
494                                             ExprValueKind VK,
495                                             CastKind K, Expr *Op,
496                                             const CXXCastPath *BasePath,
497                                             TypeSourceInfo *WrittenTy,
498                                             SourceLocation L,
499                                             SourceLocation RParenLoc) {
500  unsigned PathSize = (BasePath ? BasePath->size() : 0);
501  void *Buffer = C.Allocate(sizeof(CXXStaticCastExpr)
502                            + PathSize * sizeof(CXXBaseSpecifier*));
503  CXXStaticCastExpr *E =
504    new (Buffer) CXXStaticCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
505                                   RParenLoc);
506  if (PathSize) E->setCastPath(*BasePath);
507  return E;
508}
509
510CXXStaticCastExpr *CXXStaticCastExpr::CreateEmpty(ASTContext &C,
511                                                  unsigned PathSize) {
512  void *Buffer =
513    C.Allocate(sizeof(CXXStaticCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
514  return new (Buffer) CXXStaticCastExpr(EmptyShell(), PathSize);
515}
516
517CXXDynamicCastExpr *CXXDynamicCastExpr::Create(ASTContext &C, QualType T,
518                                               ExprValueKind VK,
519                                               CastKind K, Expr *Op,
520                                               const CXXCastPath *BasePath,
521                                               TypeSourceInfo *WrittenTy,
522                                               SourceLocation L,
523                                               SourceLocation RParenLoc) {
524  unsigned PathSize = (BasePath ? BasePath->size() : 0);
525  void *Buffer = C.Allocate(sizeof(CXXDynamicCastExpr)
526                            + PathSize * sizeof(CXXBaseSpecifier*));
527  CXXDynamicCastExpr *E =
528    new (Buffer) CXXDynamicCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
529                                    RParenLoc);
530  if (PathSize) E->setCastPath(*BasePath);
531  return E;
532}
533
534CXXDynamicCastExpr *CXXDynamicCastExpr::CreateEmpty(ASTContext &C,
535                                                    unsigned PathSize) {
536  void *Buffer =
537    C.Allocate(sizeof(CXXDynamicCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
538  return new (Buffer) CXXDynamicCastExpr(EmptyShell(), PathSize);
539}
540
541/// isAlwaysNull - Return whether the result of the dynamic_cast is proven
542/// to always be null. For example:
543///
544/// struct A { };
545/// struct B final : A { };
546/// struct C { };
547///
548/// C *f(B* b) { return dynamic_cast<C*>(b); }
549bool CXXDynamicCastExpr::isAlwaysNull() const
550{
551  QualType SrcType = getSubExpr()->getType();
552  QualType DestType = getType();
553
554  if (const PointerType *SrcPTy = SrcType->getAs<PointerType>()) {
555    SrcType = SrcPTy->getPointeeType();
556    DestType = DestType->castAs<PointerType>()->getPointeeType();
557  }
558
559  const CXXRecordDecl *SrcRD =
560    cast<CXXRecordDecl>(SrcType->castAs<RecordType>()->getDecl());
561
562  if (!SrcRD->hasAttr<FinalAttr>())
563    return false;
564
565  const CXXRecordDecl *DestRD =
566    cast<CXXRecordDecl>(DestType->castAs<RecordType>()->getDecl());
567
568  return !DestRD->isDerivedFrom(SrcRD);
569}
570
571CXXReinterpretCastExpr *
572CXXReinterpretCastExpr::Create(ASTContext &C, QualType T, ExprValueKind VK,
573                               CastKind K, Expr *Op,
574                               const CXXCastPath *BasePath,
575                               TypeSourceInfo *WrittenTy, SourceLocation L,
576                               SourceLocation RParenLoc) {
577  unsigned PathSize = (BasePath ? BasePath->size() : 0);
578  void *Buffer =
579    C.Allocate(sizeof(CXXReinterpretCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
580  CXXReinterpretCastExpr *E =
581    new (Buffer) CXXReinterpretCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
582                                        RParenLoc);
583  if (PathSize) E->setCastPath(*BasePath);
584  return E;
585}
586
587CXXReinterpretCastExpr *
588CXXReinterpretCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) {
589  void *Buffer = C.Allocate(sizeof(CXXReinterpretCastExpr)
590                            + PathSize * sizeof(CXXBaseSpecifier*));
591  return new (Buffer) CXXReinterpretCastExpr(EmptyShell(), PathSize);
592}
593
594CXXConstCastExpr *CXXConstCastExpr::Create(ASTContext &C, QualType T,
595                                           ExprValueKind VK, Expr *Op,
596                                           TypeSourceInfo *WrittenTy,
597                                           SourceLocation L,
598                                           SourceLocation RParenLoc) {
599  return new (C) CXXConstCastExpr(T, VK, Op, WrittenTy, L, RParenLoc);
600}
601
602CXXConstCastExpr *CXXConstCastExpr::CreateEmpty(ASTContext &C) {
603  return new (C) CXXConstCastExpr(EmptyShell());
604}
605
606CXXFunctionalCastExpr *
607CXXFunctionalCastExpr::Create(ASTContext &C, QualType T, ExprValueKind VK,
608                              TypeSourceInfo *Written, SourceLocation L,
609                              CastKind K, Expr *Op, const CXXCastPath *BasePath,
610                               SourceLocation R) {
611  unsigned PathSize = (BasePath ? BasePath->size() : 0);
612  void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr)
613                            + PathSize * sizeof(CXXBaseSpecifier*));
614  CXXFunctionalCastExpr *E =
615    new (Buffer) CXXFunctionalCastExpr(T, VK, Written, L, K, Op, PathSize, R);
616  if (PathSize) E->setCastPath(*BasePath);
617  return E;
618}
619
620CXXFunctionalCastExpr *
621CXXFunctionalCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) {
622  void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr)
623                            + PathSize * sizeof(CXXBaseSpecifier*));
624  return new (Buffer) CXXFunctionalCastExpr(EmptyShell(), PathSize);
625}
626
627UserDefinedLiteral::LiteralOperatorKind
628UserDefinedLiteral::getLiteralOperatorKind() const {
629  if (getNumArgs() == 0)
630    return LOK_Template;
631  if (getNumArgs() == 2)
632    return LOK_String;
633
634  assert(getNumArgs() == 1 && "unexpected #args in literal operator call");
635  QualType ParamTy =
636    cast<FunctionDecl>(getCalleeDecl())->getParamDecl(0)->getType();
637  if (ParamTy->isPointerType())
638    return LOK_Raw;
639  if (ParamTy->isAnyCharacterType())
640    return LOK_Character;
641  if (ParamTy->isIntegerType())
642    return LOK_Integer;
643  if (ParamTy->isFloatingType())
644    return LOK_Floating;
645
646  llvm_unreachable("unknown kind of literal operator");
647}
648
649Expr *UserDefinedLiteral::getCookedLiteral() {
650#ifndef NDEBUG
651  LiteralOperatorKind LOK = getLiteralOperatorKind();
652  assert(LOK != LOK_Template && LOK != LOK_Raw && "not a cooked literal");
653#endif
654  return getArg(0);
655}
656
657const IdentifierInfo *UserDefinedLiteral::getUDSuffix() const {
658  return cast<FunctionDecl>(getCalleeDecl())->getLiteralIdentifier();
659}
660
661CXXDefaultArgExpr *
662CXXDefaultArgExpr::Create(ASTContext &C, SourceLocation Loc,
663                          ParmVarDecl *Param, Expr *SubExpr) {
664  void *Mem = C.Allocate(sizeof(CXXDefaultArgExpr) + sizeof(Stmt *));
665  return new (Mem) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param,
666                                     SubExpr);
667}
668
669CXXTemporary *CXXTemporary::Create(ASTContext &C,
670                                   const CXXDestructorDecl *Destructor) {
671  return new (C) CXXTemporary(Destructor);
672}
673
674CXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(ASTContext &C,
675                                                   CXXTemporary *Temp,
676                                                   Expr* SubExpr) {
677  assert((SubExpr->getType()->isRecordType() ||
678          SubExpr->getType()->isArrayType()) &&
679         "Expression bound to a temporary must have record or array type!");
680
681  return new (C) CXXBindTemporaryExpr(Temp, SubExpr);
682}
683
684CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(ASTContext &C,
685                                               CXXConstructorDecl *Cons,
686                                               TypeSourceInfo *Type,
687                                               Expr **Args,
688                                               unsigned NumArgs,
689                                               SourceRange parenRange,
690                                               bool HadMultipleCandidates,
691                                               bool ZeroInitialization)
692  : CXXConstructExpr(C, CXXTemporaryObjectExprClass,
693                     Type->getType().getNonReferenceType(),
694                     Type->getTypeLoc().getBeginLoc(),
695                     Cons, false, Args, NumArgs,
696                     HadMultipleCandidates, /*FIXME*/false, ZeroInitialization,
697                     CXXConstructExpr::CK_Complete, parenRange),
698    Type(Type) {
699}
700
701SourceRange CXXTemporaryObjectExpr::getSourceRange() const {
702  return SourceRange(Type->getTypeLoc().getBeginLoc(),
703                     getParenRange().getEnd());
704}
705
706CXXConstructExpr *CXXConstructExpr::Create(ASTContext &C, QualType T,
707                                           SourceLocation Loc,
708                                           CXXConstructorDecl *D, bool Elidable,
709                                           Expr **Args, unsigned NumArgs,
710                                           bool HadMultipleCandidates,
711                                           bool ListInitialization,
712                                           bool ZeroInitialization,
713                                           ConstructionKind ConstructKind,
714                                           SourceRange ParenRange) {
715  return new (C) CXXConstructExpr(C, CXXConstructExprClass, T, Loc, D,
716                                  Elidable, Args, NumArgs,
717                                  HadMultipleCandidates, ListInitialization,
718                                  ZeroInitialization, ConstructKind,
719                                  ParenRange);
720}
721
722CXXConstructExpr::CXXConstructExpr(ASTContext &C, StmtClass SC, QualType T,
723                                   SourceLocation Loc,
724                                   CXXConstructorDecl *D, bool elidable,
725                                   Expr **args, unsigned numargs,
726                                   bool HadMultipleCandidates,
727                                   bool ListInitialization,
728                                   bool ZeroInitialization,
729                                   ConstructionKind ConstructKind,
730                                   SourceRange ParenRange)
731  : Expr(SC, T, VK_RValue, OK_Ordinary,
732         T->isDependentType(), T->isDependentType(),
733         T->isInstantiationDependentType(),
734         T->containsUnexpandedParameterPack()),
735    Constructor(D), Loc(Loc), ParenRange(ParenRange),  NumArgs(numargs),
736    Elidable(elidable), HadMultipleCandidates(HadMultipleCandidates),
737    ListInitialization(ListInitialization),
738    ZeroInitialization(ZeroInitialization),
739    ConstructKind(ConstructKind), Args(0)
740{
741  if (NumArgs) {
742    Args = new (C) Stmt*[NumArgs];
743
744    for (unsigned i = 0; i != NumArgs; ++i) {
745      assert(args[i] && "NULL argument in CXXConstructExpr");
746
747      if (args[i]->isValueDependent())
748        ExprBits.ValueDependent = true;
749      if (args[i]->isInstantiationDependent())
750        ExprBits.InstantiationDependent = true;
751      if (args[i]->containsUnexpandedParameterPack())
752        ExprBits.ContainsUnexpandedParameterPack = true;
753
754      Args[i] = args[i];
755    }
756  }
757}
758
759LambdaExpr::Capture::Capture(SourceLocation Loc, bool Implicit,
760                             LambdaCaptureKind Kind, VarDecl *Var,
761                             SourceLocation EllipsisLoc)
762  : VarAndBits(Var, 0), Loc(Loc), EllipsisLoc(EllipsisLoc)
763{
764  unsigned Bits = 0;
765  if (Implicit)
766    Bits |= Capture_Implicit;
767
768  switch (Kind) {
769  case LCK_This:
770    assert(Var == 0 && "'this' capture cannot have a variable!");
771    break;
772
773  case LCK_ByCopy:
774    Bits |= Capture_ByCopy;
775    // Fall through
776  case LCK_ByRef:
777    assert(Var && "capture must have a variable!");
778    break;
779  }
780  VarAndBits.setInt(Bits);
781}
782
783LambdaCaptureKind LambdaExpr::Capture::getCaptureKind() const {
784  if (capturesThis())
785    return LCK_This;
786
787  return (VarAndBits.getInt() & Capture_ByCopy)? LCK_ByCopy : LCK_ByRef;
788}
789
790LambdaExpr::LambdaExpr(QualType T,
791                       SourceRange IntroducerRange,
792                       LambdaCaptureDefault CaptureDefault,
793                       ArrayRef<Capture> Captures,
794                       bool ExplicitParams,
795                       bool ExplicitResultType,
796                       ArrayRef<Expr *> CaptureInits,
797                       ArrayRef<VarDecl *> ArrayIndexVars,
798                       ArrayRef<unsigned> ArrayIndexStarts,
799                       SourceLocation ClosingBrace)
800  : Expr(LambdaExprClass, T, VK_RValue, OK_Ordinary,
801         T->isDependentType(), T->isDependentType(), T->isDependentType(),
802         /*ContainsUnexpandedParameterPack=*/false),
803    IntroducerRange(IntroducerRange),
804    NumCaptures(Captures.size()),
805    CaptureDefault(CaptureDefault),
806    ExplicitParams(ExplicitParams),
807    ExplicitResultType(ExplicitResultType),
808    ClosingBrace(ClosingBrace)
809{
810  assert(CaptureInits.size() == Captures.size() && "Wrong number of arguments");
811  CXXRecordDecl *Class = getLambdaClass();
812  CXXRecordDecl::LambdaDefinitionData &Data = Class->getLambdaData();
813
814  // FIXME: Propagate "has unexpanded parameter pack" bit.
815
816  // Copy captures.
817  ASTContext &Context = Class->getASTContext();
818  Data.NumCaptures = NumCaptures;
819  Data.NumExplicitCaptures = 0;
820  Data.Captures = (Capture *)Context.Allocate(sizeof(Capture) * NumCaptures);
821  Capture *ToCapture = Data.Captures;
822  for (unsigned I = 0, N = Captures.size(); I != N; ++I) {
823    if (Captures[I].isExplicit())
824      ++Data.NumExplicitCaptures;
825
826    *ToCapture++ = Captures[I];
827  }
828
829  // Copy initialization expressions for the non-static data members.
830  Stmt **Stored = getStoredStmts();
831  for (unsigned I = 0, N = CaptureInits.size(); I != N; ++I)
832    *Stored++ = CaptureInits[I];
833
834  // Copy the body of the lambda.
835  *Stored++ = getCallOperator()->getBody();
836
837  // Copy the array index variables, if any.
838  HasArrayIndexVars = !ArrayIndexVars.empty();
839  if (HasArrayIndexVars) {
840    assert(ArrayIndexStarts.size() == NumCaptures);
841    memcpy(getArrayIndexVars(), ArrayIndexVars.data(),
842           sizeof(VarDecl *) * ArrayIndexVars.size());
843    memcpy(getArrayIndexStarts(), ArrayIndexStarts.data(),
844           sizeof(unsigned) * Captures.size());
845    getArrayIndexStarts()[Captures.size()] = ArrayIndexVars.size();
846  }
847}
848
849LambdaExpr *LambdaExpr::Create(ASTContext &Context,
850                               CXXRecordDecl *Class,
851                               SourceRange IntroducerRange,
852                               LambdaCaptureDefault CaptureDefault,
853                               ArrayRef<Capture> Captures,
854                               bool ExplicitParams,
855                               bool ExplicitResultType,
856                               ArrayRef<Expr *> CaptureInits,
857                               ArrayRef<VarDecl *> ArrayIndexVars,
858                               ArrayRef<unsigned> ArrayIndexStarts,
859                               SourceLocation ClosingBrace) {
860  // Determine the type of the expression (i.e., the type of the
861  // function object we're creating).
862  QualType T = Context.getTypeDeclType(Class);
863
864  unsigned Size = sizeof(LambdaExpr) + sizeof(Stmt *) * (Captures.size() + 1);
865  if (!ArrayIndexVars.empty())
866    Size += sizeof(VarDecl *) * ArrayIndexVars.size()
867          + sizeof(unsigned) * (Captures.size() + 1);
868  void *Mem = Context.Allocate(Size);
869  return new (Mem) LambdaExpr(T, IntroducerRange, CaptureDefault,
870                              Captures, ExplicitParams, ExplicitResultType,
871                              CaptureInits, ArrayIndexVars, ArrayIndexStarts,
872                              ClosingBrace);
873}
874
875LambdaExpr *LambdaExpr::CreateDeserialized(ASTContext &C, unsigned NumCaptures,
876                                           unsigned NumArrayIndexVars) {
877  unsigned Size = sizeof(LambdaExpr) + sizeof(Stmt *) * (NumCaptures + 1);
878  if (NumArrayIndexVars)
879    Size += sizeof(VarDecl) * NumArrayIndexVars
880          + sizeof(unsigned) * (NumCaptures + 1);
881  void *Mem = C.Allocate(Size);
882  return new (Mem) LambdaExpr(EmptyShell(), NumCaptures, NumArrayIndexVars > 0);
883}
884
885LambdaExpr::capture_iterator LambdaExpr::capture_begin() const {
886  return getLambdaClass()->getLambdaData().Captures;
887}
888
889LambdaExpr::capture_iterator LambdaExpr::capture_end() const {
890  return capture_begin() + NumCaptures;
891}
892
893LambdaExpr::capture_iterator LambdaExpr::explicit_capture_begin() const {
894  return capture_begin();
895}
896
897LambdaExpr::capture_iterator LambdaExpr::explicit_capture_end() const {
898  struct CXXRecordDecl::LambdaDefinitionData &Data
899    = getLambdaClass()->getLambdaData();
900  return Data.Captures + Data.NumExplicitCaptures;
901}
902
903LambdaExpr::capture_iterator LambdaExpr::implicit_capture_begin() const {
904  return explicit_capture_end();
905}
906
907LambdaExpr::capture_iterator LambdaExpr::implicit_capture_end() const {
908  return capture_end();
909}
910
911ArrayRef<VarDecl *>
912LambdaExpr::getCaptureInitIndexVars(capture_init_iterator Iter) const {
913  assert(HasArrayIndexVars && "No array index-var data?");
914
915  unsigned Index = Iter - capture_init_begin();
916  assert(Index < getLambdaClass()->getLambdaData().NumCaptures &&
917         "Capture index out-of-range");
918  VarDecl **IndexVars = getArrayIndexVars();
919  unsigned *IndexStarts = getArrayIndexStarts();
920  return ArrayRef<VarDecl *>(IndexVars + IndexStarts[Index],
921                             IndexVars + IndexStarts[Index + 1]);
922}
923
924CXXRecordDecl *LambdaExpr::getLambdaClass() const {
925  return getType()->getAsCXXRecordDecl();
926}
927
928CXXMethodDecl *LambdaExpr::getCallOperator() const {
929  CXXRecordDecl *Record = getLambdaClass();
930  DeclarationName Name
931    = Record->getASTContext().DeclarationNames.getCXXOperatorName(OO_Call);
932  DeclContext::lookup_result Calls = Record->lookup(Name);
933  assert(Calls.first != Calls.second && "Missing lambda call operator!");
934  CXXMethodDecl *Result = cast<CXXMethodDecl>(*Calls.first++);
935  assert(Calls.first == Calls.second && "More than lambda one call operator?");
936  return Result;
937}
938
939CompoundStmt *LambdaExpr::getBody() const {
940  if (!getStoredStmts()[NumCaptures])
941    getStoredStmts()[NumCaptures] = getCallOperator()->getBody();
942
943  return reinterpret_cast<CompoundStmt *>(getStoredStmts()[NumCaptures]);
944}
945
946bool LambdaExpr::isMutable() const {
947  return (getCallOperator()->getTypeQualifiers() & Qualifiers::Const) == 0;
948}
949
950ExprWithCleanups::ExprWithCleanups(Expr *subexpr,
951                                   ArrayRef<CleanupObject> objects)
952  : Expr(ExprWithCleanupsClass, subexpr->getType(),
953         subexpr->getValueKind(), subexpr->getObjectKind(),
954         subexpr->isTypeDependent(), subexpr->isValueDependent(),
955         subexpr->isInstantiationDependent(),
956         subexpr->containsUnexpandedParameterPack()),
957    SubExpr(subexpr) {
958  ExprWithCleanupsBits.NumObjects = objects.size();
959  for (unsigned i = 0, e = objects.size(); i != e; ++i)
960    getObjectsBuffer()[i] = objects[i];
961}
962
963ExprWithCleanups *ExprWithCleanups::Create(ASTContext &C, Expr *subexpr,
964                                           ArrayRef<CleanupObject> objects) {
965  size_t size = sizeof(ExprWithCleanups)
966              + objects.size() * sizeof(CleanupObject);
967  void *buffer = C.Allocate(size, llvm::alignOf<ExprWithCleanups>());
968  return new (buffer) ExprWithCleanups(subexpr, objects);
969}
970
971ExprWithCleanups::ExprWithCleanups(EmptyShell empty, unsigned numObjects)
972  : Expr(ExprWithCleanupsClass, empty) {
973  ExprWithCleanupsBits.NumObjects = numObjects;
974}
975
976ExprWithCleanups *ExprWithCleanups::Create(ASTContext &C, EmptyShell empty,
977                                           unsigned numObjects) {
978  size_t size = sizeof(ExprWithCleanups) + numObjects * sizeof(CleanupObject);
979  void *buffer = C.Allocate(size, llvm::alignOf<ExprWithCleanups>());
980  return new (buffer) ExprWithCleanups(empty, numObjects);
981}
982
983CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(TypeSourceInfo *Type,
984                                                 SourceLocation LParenLoc,
985                                                 Expr **Args,
986                                                 unsigned NumArgs,
987                                                 SourceLocation RParenLoc)
988  : Expr(CXXUnresolvedConstructExprClass,
989         Type->getType().getNonReferenceType(),
990         (Type->getType()->isLValueReferenceType() ? VK_LValue
991          :Type->getType()->isRValueReferenceType()? VK_XValue
992          :VK_RValue),
993         OK_Ordinary,
994         Type->getType()->isDependentType(), true, true,
995         Type->getType()->containsUnexpandedParameterPack()),
996    Type(Type),
997    LParenLoc(LParenLoc),
998    RParenLoc(RParenLoc),
999    NumArgs(NumArgs) {
1000  Stmt **StoredArgs = reinterpret_cast<Stmt **>(this + 1);
1001  for (unsigned I = 0; I != NumArgs; ++I) {
1002    if (Args[I]->containsUnexpandedParameterPack())
1003      ExprBits.ContainsUnexpandedParameterPack = true;
1004
1005    StoredArgs[I] = Args[I];
1006  }
1007}
1008
1009CXXUnresolvedConstructExpr *
1010CXXUnresolvedConstructExpr::Create(ASTContext &C,
1011                                   TypeSourceInfo *Type,
1012                                   SourceLocation LParenLoc,
1013                                   Expr **Args,
1014                                   unsigned NumArgs,
1015                                   SourceLocation RParenLoc) {
1016  void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) +
1017                         sizeof(Expr *) * NumArgs);
1018  return new (Mem) CXXUnresolvedConstructExpr(Type, LParenLoc,
1019                                              Args, NumArgs, RParenLoc);
1020}
1021
1022CXXUnresolvedConstructExpr *
1023CXXUnresolvedConstructExpr::CreateEmpty(ASTContext &C, unsigned NumArgs) {
1024  Stmt::EmptyShell Empty;
1025  void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) +
1026                         sizeof(Expr *) * NumArgs);
1027  return new (Mem) CXXUnresolvedConstructExpr(Empty, NumArgs);
1028}
1029
1030SourceRange CXXUnresolvedConstructExpr::getSourceRange() const {
1031  return SourceRange(Type->getTypeLoc().getBeginLoc(), RParenLoc);
1032}
1033
1034CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C,
1035                                                 Expr *Base, QualType BaseType,
1036                                                 bool IsArrow,
1037                                                 SourceLocation OperatorLoc,
1038                                          NestedNameSpecifierLoc QualifierLoc,
1039                                          SourceLocation TemplateKWLoc,
1040                                          NamedDecl *FirstQualifierFoundInScope,
1041                                          DeclarationNameInfo MemberNameInfo,
1042                                   const TemplateArgumentListInfo *TemplateArgs)
1043  : Expr(CXXDependentScopeMemberExprClass, C.DependentTy,
1044         VK_LValue, OK_Ordinary, true, true, true,
1045         ((Base && Base->containsUnexpandedParameterPack()) ||
1046          (QualifierLoc &&
1047           QualifierLoc.getNestedNameSpecifier()
1048                                       ->containsUnexpandedParameterPack()) ||
1049          MemberNameInfo.containsUnexpandedParameterPack())),
1050    Base(Base), BaseType(BaseType), IsArrow(IsArrow),
1051    HasTemplateKWAndArgsInfo(TemplateArgs != 0 || TemplateKWLoc.isValid()),
1052    OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),
1053    FirstQualifierFoundInScope(FirstQualifierFoundInScope),
1054    MemberNameInfo(MemberNameInfo) {
1055  if (TemplateArgs) {
1056    bool Dependent = true;
1057    bool InstantiationDependent = true;
1058    bool ContainsUnexpandedParameterPack = false;
1059    getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *TemplateArgs,
1060                                               Dependent,
1061                                               InstantiationDependent,
1062                                               ContainsUnexpandedParameterPack);
1063    if (ContainsUnexpandedParameterPack)
1064      ExprBits.ContainsUnexpandedParameterPack = true;
1065  } else if (TemplateKWLoc.isValid()) {
1066    getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc);
1067  }
1068}
1069
1070CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C,
1071                          Expr *Base, QualType BaseType,
1072                          bool IsArrow,
1073                          SourceLocation OperatorLoc,
1074                          NestedNameSpecifierLoc QualifierLoc,
1075                          NamedDecl *FirstQualifierFoundInScope,
1076                          DeclarationNameInfo MemberNameInfo)
1077  : Expr(CXXDependentScopeMemberExprClass, C.DependentTy,
1078         VK_LValue, OK_Ordinary, true, true, true,
1079         ((Base && Base->containsUnexpandedParameterPack()) ||
1080          (QualifierLoc &&
1081           QualifierLoc.getNestedNameSpecifier()->
1082                                         containsUnexpandedParameterPack()) ||
1083          MemberNameInfo.containsUnexpandedParameterPack())),
1084    Base(Base), BaseType(BaseType), IsArrow(IsArrow),
1085    HasTemplateKWAndArgsInfo(false),
1086    OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),
1087    FirstQualifierFoundInScope(FirstQualifierFoundInScope),
1088    MemberNameInfo(MemberNameInfo) { }
1089
1090CXXDependentScopeMemberExpr *
1091CXXDependentScopeMemberExpr::Create(ASTContext &C,
1092                                Expr *Base, QualType BaseType, bool IsArrow,
1093                                SourceLocation OperatorLoc,
1094                                NestedNameSpecifierLoc QualifierLoc,
1095                                SourceLocation TemplateKWLoc,
1096                                NamedDecl *FirstQualifierFoundInScope,
1097                                DeclarationNameInfo MemberNameInfo,
1098                                const TemplateArgumentListInfo *TemplateArgs) {
1099  if (!TemplateArgs && !TemplateKWLoc.isValid())
1100    return new (C) CXXDependentScopeMemberExpr(C, Base, BaseType,
1101                                               IsArrow, OperatorLoc,
1102                                               QualifierLoc,
1103                                               FirstQualifierFoundInScope,
1104                                               MemberNameInfo);
1105
1106  unsigned NumTemplateArgs = TemplateArgs ? TemplateArgs->size() : 0;
1107  std::size_t size = sizeof(CXXDependentScopeMemberExpr)
1108    + ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs);
1109
1110  void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>());
1111  return new (Mem) CXXDependentScopeMemberExpr(C, Base, BaseType,
1112                                               IsArrow, OperatorLoc,
1113                                               QualifierLoc,
1114                                               TemplateKWLoc,
1115                                               FirstQualifierFoundInScope,
1116                                               MemberNameInfo, TemplateArgs);
1117}
1118
1119CXXDependentScopeMemberExpr *
1120CXXDependentScopeMemberExpr::CreateEmpty(ASTContext &C,
1121                                         bool HasTemplateKWAndArgsInfo,
1122                                         unsigned NumTemplateArgs) {
1123  if (!HasTemplateKWAndArgsInfo)
1124    return new (C) CXXDependentScopeMemberExpr(C, 0, QualType(),
1125                                               0, SourceLocation(),
1126                                               NestedNameSpecifierLoc(), 0,
1127                                               DeclarationNameInfo());
1128
1129  std::size_t size = sizeof(CXXDependentScopeMemberExpr) +
1130                     ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs);
1131  void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>());
1132  CXXDependentScopeMemberExpr *E
1133    =  new (Mem) CXXDependentScopeMemberExpr(C, 0, QualType(),
1134                                             0, SourceLocation(),
1135                                             NestedNameSpecifierLoc(),
1136                                             SourceLocation(), 0,
1137                                             DeclarationNameInfo(), 0);
1138  E->HasTemplateKWAndArgsInfo = true;
1139  return E;
1140}
1141
1142bool CXXDependentScopeMemberExpr::isImplicitAccess() const {
1143  if (Base == 0)
1144    return true;
1145
1146  return cast<Expr>(Base)->isImplicitCXXThis();
1147}
1148
1149static bool hasOnlyNonStaticMemberFunctions(UnresolvedSetIterator begin,
1150                                            UnresolvedSetIterator end) {
1151  do {
1152    NamedDecl *decl = *begin;
1153    if (isa<UnresolvedUsingValueDecl>(decl))
1154      return false;
1155    if (isa<UsingShadowDecl>(decl))
1156      decl = cast<UsingShadowDecl>(decl)->getUnderlyingDecl();
1157
1158    // Unresolved member expressions should only contain methods and
1159    // method templates.
1160    assert(isa<CXXMethodDecl>(decl) || isa<FunctionTemplateDecl>(decl));
1161
1162    if (isa<FunctionTemplateDecl>(decl))
1163      decl = cast<FunctionTemplateDecl>(decl)->getTemplatedDecl();
1164    if (cast<CXXMethodDecl>(decl)->isStatic())
1165      return false;
1166  } while (++begin != end);
1167
1168  return true;
1169}
1170
1171UnresolvedMemberExpr::UnresolvedMemberExpr(ASTContext &C,
1172                                           bool HasUnresolvedUsing,
1173                                           Expr *Base, QualType BaseType,
1174                                           bool IsArrow,
1175                                           SourceLocation OperatorLoc,
1176                                           NestedNameSpecifierLoc QualifierLoc,
1177                                           SourceLocation TemplateKWLoc,
1178                                   const DeclarationNameInfo &MemberNameInfo,
1179                                   const TemplateArgumentListInfo *TemplateArgs,
1180                                           UnresolvedSetIterator Begin,
1181                                           UnresolvedSetIterator End)
1182  : OverloadExpr(UnresolvedMemberExprClass, C, QualifierLoc, TemplateKWLoc,
1183                 MemberNameInfo, TemplateArgs, Begin, End,
1184                 // Dependent
1185                 ((Base && Base->isTypeDependent()) ||
1186                  BaseType->isDependentType()),
1187                 ((Base && Base->isInstantiationDependent()) ||
1188                   BaseType->isInstantiationDependentType()),
1189                 // Contains unexpanded parameter pack
1190                 ((Base && Base->containsUnexpandedParameterPack()) ||
1191                  BaseType->containsUnexpandedParameterPack())),
1192    IsArrow(IsArrow), HasUnresolvedUsing(HasUnresolvedUsing),
1193    Base(Base), BaseType(BaseType), OperatorLoc(OperatorLoc) {
1194
1195  // Check whether all of the members are non-static member functions,
1196  // and if so, mark give this bound-member type instead of overload type.
1197  if (hasOnlyNonStaticMemberFunctions(Begin, End))
1198    setType(C.BoundMemberTy);
1199}
1200
1201bool UnresolvedMemberExpr::isImplicitAccess() const {
1202  if (Base == 0)
1203    return true;
1204
1205  return cast<Expr>(Base)->isImplicitCXXThis();
1206}
1207
1208UnresolvedMemberExpr *
1209UnresolvedMemberExpr::Create(ASTContext &C,
1210                             bool HasUnresolvedUsing,
1211                             Expr *Base, QualType BaseType, bool IsArrow,
1212                             SourceLocation OperatorLoc,
1213                             NestedNameSpecifierLoc QualifierLoc,
1214                             SourceLocation TemplateKWLoc,
1215                             const DeclarationNameInfo &MemberNameInfo,
1216                             const TemplateArgumentListInfo *TemplateArgs,
1217                             UnresolvedSetIterator Begin,
1218                             UnresolvedSetIterator End) {
1219  std::size_t size = sizeof(UnresolvedMemberExpr);
1220  if (TemplateArgs)
1221    size += ASTTemplateKWAndArgsInfo::sizeFor(TemplateArgs->size());
1222  else if (TemplateKWLoc.isValid())
1223    size += ASTTemplateKWAndArgsInfo::sizeFor(0);
1224
1225  void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>());
1226  return new (Mem) UnresolvedMemberExpr(C,
1227                             HasUnresolvedUsing, Base, BaseType,
1228                             IsArrow, OperatorLoc, QualifierLoc, TemplateKWLoc,
1229                             MemberNameInfo, TemplateArgs, Begin, End);
1230}
1231
1232UnresolvedMemberExpr *
1233UnresolvedMemberExpr::CreateEmpty(ASTContext &C, bool HasTemplateKWAndArgsInfo,
1234                                  unsigned NumTemplateArgs) {
1235  std::size_t size = sizeof(UnresolvedMemberExpr);
1236  if (HasTemplateKWAndArgsInfo)
1237    size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs);
1238
1239  void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>());
1240  UnresolvedMemberExpr *E = new (Mem) UnresolvedMemberExpr(EmptyShell());
1241  E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo;
1242  return E;
1243}
1244
1245CXXRecordDecl *UnresolvedMemberExpr::getNamingClass() const {
1246  // Unlike for UnresolvedLookupExpr, it is very easy to re-derive this.
1247
1248  // If there was a nested name specifier, it names the naming class.
1249  // It can't be dependent: after all, we were actually able to do the
1250  // lookup.
1251  CXXRecordDecl *Record = 0;
1252  if (getQualifier()) {
1253    const Type *T = getQualifier()->getAsType();
1254    assert(T && "qualifier in member expression does not name type");
1255    Record = T->getAsCXXRecordDecl();
1256    assert(Record && "qualifier in member expression does not name record");
1257  }
1258  // Otherwise the naming class must have been the base class.
1259  else {
1260    QualType BaseType = getBaseType().getNonReferenceType();
1261    if (isArrow()) {
1262      const PointerType *PT = BaseType->getAs<PointerType>();
1263      assert(PT && "base of arrow member access is not pointer");
1264      BaseType = PT->getPointeeType();
1265    }
1266
1267    Record = BaseType->getAsCXXRecordDecl();
1268    assert(Record && "base of member expression does not name record");
1269  }
1270
1271  return Record;
1272}
1273
1274SubstNonTypeTemplateParmPackExpr::
1275SubstNonTypeTemplateParmPackExpr(QualType T,
1276                                 NonTypeTemplateParmDecl *Param,
1277                                 SourceLocation NameLoc,
1278                                 const TemplateArgument &ArgPack)
1279  : Expr(SubstNonTypeTemplateParmPackExprClass, T, VK_RValue, OK_Ordinary,
1280         true, true, true, true),
1281    Param(Param), Arguments(ArgPack.pack_begin()),
1282    NumArguments(ArgPack.pack_size()), NameLoc(NameLoc) { }
1283
1284TemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const {
1285  return TemplateArgument(Arguments, NumArguments);
1286}
1287
1288TypeTraitExpr::TypeTraitExpr(QualType T, SourceLocation Loc, TypeTrait Kind,
1289                             ArrayRef<TypeSourceInfo *> Args,
1290                             SourceLocation RParenLoc,
1291                             bool Value)
1292  : Expr(TypeTraitExprClass, T, VK_RValue, OK_Ordinary,
1293         /*TypeDependent=*/false,
1294         /*ValueDependent=*/false,
1295         /*InstantiationDependent=*/false,
1296         /*ContainsUnexpandedParameterPack=*/false),
1297    Loc(Loc), RParenLoc(RParenLoc)
1298{
1299  TypeTraitExprBits.Kind = Kind;
1300  TypeTraitExprBits.Value = Value;
1301  TypeTraitExprBits.NumArgs = Args.size();
1302
1303  TypeSourceInfo **ToArgs = getTypeSourceInfos();
1304
1305  for (unsigned I = 0, N = Args.size(); I != N; ++I) {
1306    if (Args[I]->getType()->isDependentType())
1307      setValueDependent(true);
1308    if (Args[I]->getType()->isInstantiationDependentType())
1309      setInstantiationDependent(true);
1310    if (Args[I]->getType()->containsUnexpandedParameterPack())
1311      setContainsUnexpandedParameterPack(true);
1312
1313    ToArgs[I] = Args[I];
1314  }
1315}
1316
1317TypeTraitExpr *TypeTraitExpr::Create(ASTContext &C, QualType T,
1318                                     SourceLocation Loc,
1319                                     TypeTrait Kind,
1320                                     ArrayRef<TypeSourceInfo *> Args,
1321                                     SourceLocation RParenLoc,
1322                                     bool Value) {
1323  unsigned Size = sizeof(TypeTraitExpr) + sizeof(TypeSourceInfo*) * Args.size();
1324  void *Mem = C.Allocate(Size);
1325  return new (Mem) TypeTraitExpr(T, Loc, Kind, Args, RParenLoc, Value);
1326}
1327
1328TypeTraitExpr *TypeTraitExpr::CreateDeserialized(ASTContext &C,
1329                                                 unsigned NumArgs) {
1330  unsigned Size = sizeof(TypeTraitExpr) + sizeof(TypeSourceInfo*) * NumArgs;
1331  void *Mem = C.Allocate(Size);
1332  return new (Mem) TypeTraitExpr(EmptyShell());
1333}
1334
1335void ArrayTypeTraitExpr::anchor() { }
1336