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