Expr.cpp revision f85e193739c953358c865005855253af4f68a497 
1//===--- Expr.cpp - 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 Expr class and subclasses.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/AST/Expr.h"
15#include "clang/AST/ExprCXX.h"
16#include "clang/AST/APValue.h"
17#include "clang/AST/ASTContext.h"
18#include "clang/AST/DeclObjC.h"
19#include "clang/AST/DeclCXX.h"
20#include "clang/AST/DeclTemplate.h"
21#include "clang/AST/RecordLayout.h"
22#include "clang/AST/StmtVisitor.h"
23#include "clang/Lex/LiteralSupport.h"
24#include "clang/Lex/Lexer.h"
25#include "clang/Sema/SemaDiagnostic.h"
26#include "clang/Basic/Builtins.h"
27#include "clang/Basic/SourceManager.h"
28#include "clang/Basic/TargetInfo.h"
29#include "llvm/Support/ErrorHandling.h"
30#include "llvm/Support/raw_ostream.h"
31#include <algorithm>
32using namespace clang;
33
34/// isKnownToHaveBooleanValue - Return true if this is an integer expression
35/// that is known to return 0 or 1.  This happens for _Bool/bool expressions
36/// but also int expressions which are produced by things like comparisons in
37/// C.
38bool Expr::isKnownToHaveBooleanValue() const {
39  const Expr *E = IgnoreParens();
40
41  // If this value has _Bool type, it is obvious 0/1.
42  if (E->getType()->isBooleanType()) return true;
43  // If this is a non-scalar-integer type, we don't care enough to try.
44  if (!E->getType()->isIntegralOrEnumerationType()) return false;
45
46  if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
47    switch (UO->getOpcode()) {
48    case UO_Plus:
49      return UO->getSubExpr()->isKnownToHaveBooleanValue();
50    default:
51      return false;
52    }
53  }
54
55  // Only look through implicit casts.  If the user writes
56  // '(int) (a && b)' treat it as an arbitrary int.
57  if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E))
58    return CE->getSubExpr()->isKnownToHaveBooleanValue();
59
60  if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
61    switch (BO->getOpcode()) {
62    default: return false;
63    case BO_LT:   // Relational operators.
64    case BO_GT:
65    case BO_LE:
66    case BO_GE:
67    case BO_EQ:   // Equality operators.
68    case BO_NE:
69    case BO_LAnd: // AND operator.
70    case BO_LOr:  // Logical OR operator.
71      return true;
72
73    case BO_And:  // Bitwise AND operator.
74    case BO_Xor:  // Bitwise XOR operator.
75    case BO_Or:   // Bitwise OR operator.
76      // Handle things like (x==2)|(y==12).
77      return BO->getLHS()->isKnownToHaveBooleanValue() &&
78             BO->getRHS()->isKnownToHaveBooleanValue();
79
80    case BO_Comma:
81    case BO_Assign:
82      return BO->getRHS()->isKnownToHaveBooleanValue();
83    }
84  }
85
86  if (const ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E))
87    return CO->getTrueExpr()->isKnownToHaveBooleanValue() &&
88           CO->getFalseExpr()->isKnownToHaveBooleanValue();
89
90  return false;
91}
92
93// Amusing macro metaprogramming hack: check whether a class provides
94// a more specific implementation of getExprLoc().
95namespace {
96  /// This implementation is used when a class provides a custom
97  /// implementation of getExprLoc.
98  template <class E, class T>
99  SourceLocation getExprLocImpl(const Expr *expr,
100                                SourceLocation (T::*v)() const) {
101    return static_cast<const E*>(expr)->getExprLoc();
102  }
103
104  /// This implementation is used when a class doesn't provide
105  /// a custom implementation of getExprLoc.  Overload resolution
106  /// should pick it over the implementation above because it's
107  /// more specialized according to function template partial ordering.
108  template <class E>
109  SourceLocation getExprLocImpl(const Expr *expr,
110                                SourceLocation (Expr::*v)() const) {
111    return static_cast<const E*>(expr)->getSourceRange().getBegin();
112  }
113}
114
115SourceLocation Expr::getExprLoc() const {
116  switch (getStmtClass()) {
117  case Stmt::NoStmtClass: llvm_unreachable("statement without class");
118#define ABSTRACT_STMT(type)
119#define STMT(type, base) \
120  case Stmt::type##Class: llvm_unreachable(#type " is not an Expr"); break;
121#define EXPR(type, base) \
122  case Stmt::type##Class: return getExprLocImpl<type>(this, &type::getExprLoc);
123#include "clang/AST/StmtNodes.inc"
124  }
125  llvm_unreachable("unknown statement kind");
126  return SourceLocation();
127}
128
129//===----------------------------------------------------------------------===//
130// Primary Expressions.
131//===----------------------------------------------------------------------===//
132
133void ExplicitTemplateArgumentList::initializeFrom(
134                                      const TemplateArgumentListInfo &Info) {
135  LAngleLoc = Info.getLAngleLoc();
136  RAngleLoc = Info.getRAngleLoc();
137  NumTemplateArgs = Info.size();
138
139  TemplateArgumentLoc *ArgBuffer = getTemplateArgs();
140  for (unsigned i = 0; i != NumTemplateArgs; ++i)
141    new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
142}
143
144void ExplicitTemplateArgumentList::initializeFrom(
145                                   const TemplateArgumentListInfo &Info,
146                                   bool &Dependent,
147                                   bool &ContainsUnexpandedParameterPack) {
148  LAngleLoc = Info.getLAngleLoc();
149  RAngleLoc = Info.getRAngleLoc();
150  NumTemplateArgs = Info.size();
151
152  TemplateArgumentLoc *ArgBuffer = getTemplateArgs();
153  for (unsigned i = 0; i != NumTemplateArgs; ++i) {
154    Dependent = Dependent || Info[i].getArgument().isDependent();
155    ContainsUnexpandedParameterPack
156      = ContainsUnexpandedParameterPack ||
157        Info[i].getArgument().containsUnexpandedParameterPack();
158
159    new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
160  }
161}
162
163void ExplicitTemplateArgumentList::copyInto(
164                                      TemplateArgumentListInfo &Info) const {
165  Info.setLAngleLoc(LAngleLoc);
166  Info.setRAngleLoc(RAngleLoc);
167  for (unsigned I = 0; I != NumTemplateArgs; ++I)
168    Info.addArgument(getTemplateArgs()[I]);
169}
170
171std::size_t ExplicitTemplateArgumentList::sizeFor(unsigned NumTemplateArgs) {
172  return sizeof(ExplicitTemplateArgumentList) +
173         sizeof(TemplateArgumentLoc) * NumTemplateArgs;
174}
175
176std::size_t ExplicitTemplateArgumentList::sizeFor(
177                                      const TemplateArgumentListInfo &Info) {
178  return sizeFor(Info.size());
179}
180
181/// \brief Compute the type- and value-dependence of a declaration reference
182/// based on the declaration being referenced.
183static void computeDeclRefDependence(NamedDecl *D, QualType T,
184                                     bool &TypeDependent,
185                                     bool &ValueDependent) {
186  TypeDependent = false;
187  ValueDependent = false;
188
189
190  // (TD) C++ [temp.dep.expr]p3:
191  //   An id-expression is type-dependent if it contains:
192  //
193  // and
194  //
195  // (VD) C++ [temp.dep.constexpr]p2:
196  //  An identifier is value-dependent if it is:
197
198  //  (TD)  - an identifier that was declared with dependent type
199  //  (VD)  - a name declared with a dependent type,
200  if (T->isDependentType()) {
201    TypeDependent = true;
202    ValueDependent = true;
203    return;
204  }
205
206  //  (TD)  - a conversion-function-id that specifies a dependent type
207  if (D->getDeclName().getNameKind()
208           == DeclarationName::CXXConversionFunctionName &&
209           D->getDeclName().getCXXNameType()->isDependentType()) {
210    TypeDependent = true;
211    ValueDependent = true;
212    return;
213  }
214  //  (VD)  - the name of a non-type template parameter,
215  if (isa<NonTypeTemplateParmDecl>(D)) {
216    ValueDependent = true;
217    return;
218  }
219
220  //  (VD) - a constant with integral or enumeration type and is
221  //         initialized with an expression that is value-dependent.
222  if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
223    if (Var->getType()->isIntegralOrEnumerationType() &&
224        Var->getType().getCVRQualifiers() == Qualifiers::Const) {
225      if (const Expr *Init = Var->getAnyInitializer())
226        if (Init->isValueDependent())
227          ValueDependent = true;
228    }
229
230    // (VD) - FIXME: Missing from the standard:
231    //      -  a member function or a static data member of the current
232    //         instantiation
233    else if (Var->isStaticDataMember() &&
234             Var->getDeclContext()->isDependentContext())
235      ValueDependent = true;
236
237    return;
238  }
239
240  // (VD) - FIXME: Missing from the standard:
241  //      -  a member function or a static data member of the current
242  //         instantiation
243  if (isa<CXXMethodDecl>(D) && D->getDeclContext()->isDependentContext()) {
244    ValueDependent = true;
245    return;
246  }
247}
248
249void DeclRefExpr::computeDependence() {
250  bool TypeDependent = false;
251  bool ValueDependent = false;
252  computeDeclRefDependence(getDecl(), getType(), TypeDependent, ValueDependent);
253
254  // (TD) C++ [temp.dep.expr]p3:
255  //   An id-expression is type-dependent if it contains:
256  //
257  // and
258  //
259  // (VD) C++ [temp.dep.constexpr]p2:
260  //  An identifier is value-dependent if it is:
261  if (!TypeDependent && !ValueDependent &&
262      hasExplicitTemplateArgs() &&
263      TemplateSpecializationType::anyDependentTemplateArguments(
264                                                            getTemplateArgs(),
265                                                       getNumTemplateArgs())) {
266    TypeDependent = true;
267    ValueDependent = true;
268  }
269
270  ExprBits.TypeDependent = TypeDependent;
271  ExprBits.ValueDependent = ValueDependent;
272
273  // Is the declaration a parameter pack?
274  if (getDecl()->isParameterPack())
275    ExprBits.ContainsUnexpandedParameterPack = true;
276}
277
278DeclRefExpr::DeclRefExpr(NestedNameSpecifierLoc QualifierLoc,
279                         ValueDecl *D, const DeclarationNameInfo &NameInfo,
280                         NamedDecl *FoundD,
281                         const TemplateArgumentListInfo *TemplateArgs,
282                         QualType T, ExprValueKind VK)
283  : Expr(DeclRefExprClass, T, VK, OK_Ordinary, false, false, false),
284    D(D), Loc(NameInfo.getLoc()), DNLoc(NameInfo.getInfo()) {
285  DeclRefExprBits.HasQualifier = QualifierLoc ? 1 : 0;
286  if (QualifierLoc)
287    getInternalQualifierLoc() = QualifierLoc;
288  DeclRefExprBits.HasFoundDecl = FoundD ? 1 : 0;
289  if (FoundD)
290    getInternalFoundDecl() = FoundD;
291  DeclRefExprBits.HasExplicitTemplateArgs = TemplateArgs ? 1 : 0;
292  if (TemplateArgs)
293    getExplicitTemplateArgs().initializeFrom(*TemplateArgs);
294
295  computeDependence();
296}
297
298DeclRefExpr *DeclRefExpr::Create(ASTContext &Context,
299                                 NestedNameSpecifierLoc QualifierLoc,
300                                 ValueDecl *D,
301                                 SourceLocation NameLoc,
302                                 QualType T,
303                                 ExprValueKind VK,
304                                 NamedDecl *FoundD,
305                                 const TemplateArgumentListInfo *TemplateArgs) {
306  return Create(Context, QualifierLoc, D,
307                DeclarationNameInfo(D->getDeclName(), NameLoc),
308                T, VK, FoundD, TemplateArgs);
309}
310
311DeclRefExpr *DeclRefExpr::Create(ASTContext &Context,
312                                 NestedNameSpecifierLoc QualifierLoc,
313                                 ValueDecl *D,
314                                 const DeclarationNameInfo &NameInfo,
315                                 QualType T,
316                                 ExprValueKind VK,
317                                 NamedDecl *FoundD,
318                                 const TemplateArgumentListInfo *TemplateArgs) {
319  // Filter out cases where the found Decl is the same as the value refenenced.
320  if (D == FoundD)
321    FoundD = 0;
322
323  std::size_t Size = sizeof(DeclRefExpr);
324  if (QualifierLoc != 0)
325    Size += sizeof(NestedNameSpecifierLoc);
326  if (FoundD)
327    Size += sizeof(NamedDecl *);
328  if (TemplateArgs)
329    Size += ExplicitTemplateArgumentList::sizeFor(*TemplateArgs);
330
331  void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>());
332  return new (Mem) DeclRefExpr(QualifierLoc, D, NameInfo, FoundD, TemplateArgs,
333                               T, VK);
334}
335
336DeclRefExpr *DeclRefExpr::CreateEmpty(ASTContext &Context,
337                                      bool HasQualifier,
338                                      bool HasFoundDecl,
339                                      bool HasExplicitTemplateArgs,
340                                      unsigned NumTemplateArgs) {
341  std::size_t Size = sizeof(DeclRefExpr);
342  if (HasQualifier)
343    Size += sizeof(NestedNameSpecifierLoc);
344  if (HasFoundDecl)
345    Size += sizeof(NamedDecl *);
346  if (HasExplicitTemplateArgs)
347    Size += ExplicitTemplateArgumentList::sizeFor(NumTemplateArgs);
348
349  void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>());
350  return new (Mem) DeclRefExpr(EmptyShell());
351}
352
353SourceRange DeclRefExpr::getSourceRange() const {
354  SourceRange R = getNameInfo().getSourceRange();
355  if (hasQualifier())
356    R.setBegin(getQualifierLoc().getBeginLoc());
357  if (hasExplicitTemplateArgs())
358    R.setEnd(getRAngleLoc());
359  return R;
360}
361
362// FIXME: Maybe this should use DeclPrinter with a special "print predefined
363// expr" policy instead.
364std::string PredefinedExpr::ComputeName(IdentType IT, const Decl *CurrentDecl) {
365  ASTContext &Context = CurrentDecl->getASTContext();
366
367  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) {
368    if (IT != PrettyFunction && IT != PrettyFunctionNoVirtual)
369      return FD->getNameAsString();
370
371    llvm::SmallString<256> Name;
372    llvm::raw_svector_ostream Out(Name);
373
374    if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
375      if (MD->isVirtual() && IT != PrettyFunctionNoVirtual)
376        Out << "virtual ";
377      if (MD->isStatic())
378        Out << "static ";
379    }
380
381    PrintingPolicy Policy(Context.getLangOptions());
382
383    std::string Proto = FD->getQualifiedNameAsString(Policy);
384
385    const FunctionType *AFT = FD->getType()->getAs<FunctionType>();
386    const FunctionProtoType *FT = 0;
387    if (FD->hasWrittenPrototype())
388      FT = dyn_cast<FunctionProtoType>(AFT);
389
390    Proto += "(";
391    if (FT) {
392      llvm::raw_string_ostream POut(Proto);
393      for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) {
394        if (i) POut << ", ";
395        std::string Param;
396        FD->getParamDecl(i)->getType().getAsStringInternal(Param, Policy);
397        POut << Param;
398      }
399
400      if (FT->isVariadic()) {
401        if (FD->getNumParams()) POut << ", ";
402        POut << "...";
403      }
404    }
405    Proto += ")";
406
407    if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
408      Qualifiers ThisQuals = Qualifiers::fromCVRMask(MD->getTypeQualifiers());
409      if (ThisQuals.hasConst())
410        Proto += " const";
411      if (ThisQuals.hasVolatile())
412        Proto += " volatile";
413    }
414
415    if (!isa<CXXConstructorDecl>(FD) && !isa<CXXDestructorDecl>(FD))
416      AFT->getResultType().getAsStringInternal(Proto, Policy);
417
418    Out << Proto;
419
420    Out.flush();
421    return Name.str().str();
422  }
423  if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) {
424    llvm::SmallString<256> Name;
425    llvm::raw_svector_ostream Out(Name);
426    Out << (MD->isInstanceMethod() ? '-' : '+');
427    Out << '[';
428
429    // For incorrect code, there might not be an ObjCInterfaceDecl.  Do
430    // a null check to avoid a crash.
431    if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
432      Out << ID;
433
434    if (const ObjCCategoryImplDecl *CID =
435        dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext()))
436      Out << '(' << CID << ')';
437
438    Out <<  ' ';
439    Out << MD->getSelector().getAsString();
440    Out <<  ']';
441
442    Out.flush();
443    return Name.str().str();
444  }
445  if (isa<TranslationUnitDecl>(CurrentDecl) && IT == PrettyFunction) {
446    // __PRETTY_FUNCTION__ -> "top level", the others produce an empty string.
447    return "top level";
448  }
449  return "";
450}
451
452void APNumericStorage::setIntValue(ASTContext &C, const llvm::APInt &Val) {
453  if (hasAllocation())
454    C.Deallocate(pVal);
455
456  BitWidth = Val.getBitWidth();
457  unsigned NumWords = Val.getNumWords();
458  const uint64_t* Words = Val.getRawData();
459  if (NumWords > 1) {
460    pVal = new (C) uint64_t[NumWords];
461    std::copy(Words, Words + NumWords, pVal);
462  } else if (NumWords == 1)
463    VAL = Words[0];
464  else
465    VAL = 0;
466}
467
468IntegerLiteral *
469IntegerLiteral::Create(ASTContext &C, const llvm::APInt &V,
470                       QualType type, SourceLocation l) {
471  return new (C) IntegerLiteral(C, V, type, l);
472}
473
474IntegerLiteral *
475IntegerLiteral::Create(ASTContext &C, EmptyShell Empty) {
476  return new (C) IntegerLiteral(Empty);
477}
478
479FloatingLiteral *
480FloatingLiteral::Create(ASTContext &C, const llvm::APFloat &V,
481                        bool isexact, QualType Type, SourceLocation L) {
482  return new (C) FloatingLiteral(C, V, isexact, Type, L);
483}
484
485FloatingLiteral *
486FloatingLiteral::Create(ASTContext &C, EmptyShell Empty) {
487  return new (C) FloatingLiteral(Empty);
488}
489
490/// getValueAsApproximateDouble - This returns the value as an inaccurate
491/// double.  Note that this may cause loss of precision, but is useful for
492/// debugging dumps, etc.
493double FloatingLiteral::getValueAsApproximateDouble() const {
494  llvm::APFloat V = getValue();
495  bool ignored;
496  V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven,
497            &ignored);
498  return V.convertToDouble();
499}
500
501StringLiteral *StringLiteral::Create(ASTContext &C, const char *StrData,
502                                     unsigned ByteLength, bool Wide,
503                                     bool Pascal, QualType Ty,
504                                     const SourceLocation *Loc,
505                                     unsigned NumStrs) {
506  // Allocate enough space for the StringLiteral plus an array of locations for
507  // any concatenated string tokens.
508  void *Mem = C.Allocate(sizeof(StringLiteral)+
509                         sizeof(SourceLocation)*(NumStrs-1),
510                         llvm::alignOf<StringLiteral>());
511  StringLiteral *SL = new (Mem) StringLiteral(Ty);
512
513  // OPTIMIZE: could allocate this appended to the StringLiteral.
514  char *AStrData = new (C, 1) char[ByteLength];
515  memcpy(AStrData, StrData, ByteLength);
516  SL->StrData = AStrData;
517  SL->ByteLength = ByteLength;
518  SL->IsWide = Wide;
519  SL->IsPascal = Pascal;
520  SL->TokLocs[0] = Loc[0];
521  SL->NumConcatenated = NumStrs;
522
523  if (NumStrs != 1)
524    memcpy(&SL->TokLocs[1], Loc+1, sizeof(SourceLocation)*(NumStrs-1));
525  return SL;
526}
527
528StringLiteral *StringLiteral::CreateEmpty(ASTContext &C, unsigned NumStrs) {
529  void *Mem = C.Allocate(sizeof(StringLiteral)+
530                         sizeof(SourceLocation)*(NumStrs-1),
531                         llvm::alignOf<StringLiteral>());
532  StringLiteral *SL = new (Mem) StringLiteral(QualType());
533  SL->StrData = 0;
534  SL->ByteLength = 0;
535  SL->NumConcatenated = NumStrs;
536  return SL;
537}
538
539void StringLiteral::setString(ASTContext &C, llvm::StringRef Str) {
540  char *AStrData = new (C, 1) char[Str.size()];
541  memcpy(AStrData, Str.data(), Str.size());
542  StrData = AStrData;
543  ByteLength = Str.size();
544}
545
546/// getLocationOfByte - Return a source location that points to the specified
547/// byte of this string literal.
548///
549/// Strings are amazingly complex.  They can be formed from multiple tokens and
550/// can have escape sequences in them in addition to the usual trigraph and
551/// escaped newline business.  This routine handles this complexity.
552///
553SourceLocation StringLiteral::
554getLocationOfByte(unsigned ByteNo, const SourceManager &SM,
555                  const LangOptions &Features, const TargetInfo &Target) const {
556  assert(!isWide() && "This doesn't work for wide strings yet");
557
558  // Loop over all of the tokens in this string until we find the one that
559  // contains the byte we're looking for.
560  unsigned TokNo = 0;
561  while (1) {
562    assert(TokNo < getNumConcatenated() && "Invalid byte number!");
563    SourceLocation StrTokLoc = getStrTokenLoc(TokNo);
564
565    // Get the spelling of the string so that we can get the data that makes up
566    // the string literal, not the identifier for the macro it is potentially
567    // expanded through.
568    SourceLocation StrTokSpellingLoc = SM.getSpellingLoc(StrTokLoc);
569
570    // Re-lex the token to get its length and original spelling.
571    std::pair<FileID, unsigned> LocInfo =SM.getDecomposedLoc(StrTokSpellingLoc);
572    bool Invalid = false;
573    llvm::StringRef Buffer = SM.getBufferData(LocInfo.first, &Invalid);
574    if (Invalid)
575      return StrTokSpellingLoc;
576
577    const char *StrData = Buffer.data()+LocInfo.second;
578
579    // Create a langops struct and enable trigraphs.  This is sufficient for
580    // relexing tokens.
581    LangOptions LangOpts;
582    LangOpts.Trigraphs = true;
583
584    // Create a lexer starting at the beginning of this token.
585    Lexer TheLexer(StrTokSpellingLoc, Features, Buffer.begin(), StrData,
586                   Buffer.end());
587    Token TheTok;
588    TheLexer.LexFromRawLexer(TheTok);
589
590    // Use the StringLiteralParser to compute the length of the string in bytes.
591    StringLiteralParser SLP(&TheTok, 1, SM, Features, Target);
592    unsigned TokNumBytes = SLP.GetStringLength();
593
594    // If the byte is in this token, return the location of the byte.
595    if (ByteNo < TokNumBytes ||
596        (ByteNo == TokNumBytes && TokNo == getNumConcatenated())) {
597      unsigned Offset = SLP.getOffsetOfStringByte(TheTok, ByteNo);
598
599      // Now that we know the offset of the token in the spelling, use the
600      // preprocessor to get the offset in the original source.
601      return Lexer::AdvanceToTokenCharacter(StrTokLoc, Offset, SM, Features);
602    }
603
604    // Move to the next string token.
605    ++TokNo;
606    ByteNo -= TokNumBytes;
607  }
608}
609
610
611
612/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
613/// corresponds to, e.g. "sizeof" or "[pre]++".
614const char *UnaryOperator::getOpcodeStr(Opcode Op) {
615  switch (Op) {
616  default: assert(0 && "Unknown unary operator");
617  case UO_PostInc: return "++";
618  case UO_PostDec: return "--";
619  case UO_PreInc:  return "++";
620  case UO_PreDec:  return "--";
621  case UO_AddrOf:  return "&";
622  case UO_Deref:   return "*";
623  case UO_Plus:    return "+";
624  case UO_Minus:   return "-";
625  case UO_Not:     return "~";
626  case UO_LNot:    return "!";
627  case UO_Real:    return "__real";
628  case UO_Imag:    return "__imag";
629  case UO_Extension: return "__extension__";
630  }
631}
632
633UnaryOperatorKind
634UnaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix) {
635  switch (OO) {
636  default: assert(false && "No unary operator for overloaded function");
637  case OO_PlusPlus:   return Postfix ? UO_PostInc : UO_PreInc;
638  case OO_MinusMinus: return Postfix ? UO_PostDec : UO_PreDec;
639  case OO_Amp:        return UO_AddrOf;
640  case OO_Star:       return UO_Deref;
641  case OO_Plus:       return UO_Plus;
642  case OO_Minus:      return UO_Minus;
643  case OO_Tilde:      return UO_Not;
644  case OO_Exclaim:    return UO_LNot;
645  }
646}
647
648OverloadedOperatorKind UnaryOperator::getOverloadedOperator(Opcode Opc) {
649  switch (Opc) {
650  case UO_PostInc: case UO_PreInc: return OO_PlusPlus;
651  case UO_PostDec: case UO_PreDec: return OO_MinusMinus;
652  case UO_AddrOf: return OO_Amp;
653  case UO_Deref: return OO_Star;
654  case UO_Plus: return OO_Plus;
655  case UO_Minus: return OO_Minus;
656  case UO_Not: return OO_Tilde;
657  case UO_LNot: return OO_Exclaim;
658  default: return OO_None;
659  }
660}
661
662
663//===----------------------------------------------------------------------===//
664// Postfix Operators.
665//===----------------------------------------------------------------------===//
666
667CallExpr::CallExpr(ASTContext& C, StmtClass SC, Expr *fn, unsigned NumPreArgs,
668                   Expr **args, unsigned numargs, QualType t, ExprValueKind VK,
669                   SourceLocation rparenloc)
670  : Expr(SC, t, VK, OK_Ordinary,
671         fn->isTypeDependent(),
672         fn->isValueDependent(),
673         fn->containsUnexpandedParameterPack()),
674    NumArgs(numargs) {
675
676  SubExprs = new (C) Stmt*[numargs+PREARGS_START+NumPreArgs];
677  SubExprs[FN] = fn;
678  for (unsigned i = 0; i != numargs; ++i) {
679    if (args[i]->isTypeDependent())
680      ExprBits.TypeDependent = true;
681    if (args[i]->isValueDependent())
682      ExprBits.ValueDependent = true;
683    if (args[i]->containsUnexpandedParameterPack())
684      ExprBits.ContainsUnexpandedParameterPack = true;
685
686    SubExprs[i+PREARGS_START+NumPreArgs] = args[i];
687  }
688
689  CallExprBits.NumPreArgs = NumPreArgs;
690  RParenLoc = rparenloc;
691}
692
693CallExpr::CallExpr(ASTContext& C, Expr *fn, Expr **args, unsigned numargs,
694                   QualType t, ExprValueKind VK, SourceLocation rparenloc)
695  : Expr(CallExprClass, t, VK, OK_Ordinary,
696         fn->isTypeDependent(),
697         fn->isValueDependent(),
698         fn->containsUnexpandedParameterPack()),
699    NumArgs(numargs) {
700
701  SubExprs = new (C) Stmt*[numargs+PREARGS_START];
702  SubExprs[FN] = fn;
703  for (unsigned i = 0; i != numargs; ++i) {
704    if (args[i]->isTypeDependent())
705      ExprBits.TypeDependent = true;
706    if (args[i]->isValueDependent())
707      ExprBits.ValueDependent = true;
708    if (args[i]->containsUnexpandedParameterPack())
709      ExprBits.ContainsUnexpandedParameterPack = true;
710
711    SubExprs[i+PREARGS_START] = args[i];
712  }
713
714  CallExprBits.NumPreArgs = 0;
715  RParenLoc = rparenloc;
716}
717
718CallExpr::CallExpr(ASTContext &C, StmtClass SC, EmptyShell Empty)
719  : Expr(SC, Empty), SubExprs(0), NumArgs(0) {
720  // FIXME: Why do we allocate this?
721  SubExprs = new (C) Stmt*[PREARGS_START];
722  CallExprBits.NumPreArgs = 0;
723}
724
725CallExpr::CallExpr(ASTContext &C, StmtClass SC, unsigned NumPreArgs,
726                   EmptyShell Empty)
727  : Expr(SC, Empty), SubExprs(0), NumArgs(0) {
728  // FIXME: Why do we allocate this?
729  SubExprs = new (C) Stmt*[PREARGS_START+NumPreArgs];
730  CallExprBits.NumPreArgs = NumPreArgs;
731}
732
733Decl *CallExpr::getCalleeDecl() {
734  Expr *CEE = getCallee()->IgnoreParenCasts();
735  // If we're calling a dereference, look at the pointer instead.
736  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(CEE)) {
737    if (BO->isPtrMemOp())
738      CEE = BO->getRHS()->IgnoreParenCasts();
739  } else if (UnaryOperator *UO = dyn_cast<UnaryOperator>(CEE)) {
740    if (UO->getOpcode() == UO_Deref)
741      CEE = UO->getSubExpr()->IgnoreParenCasts();
742  }
743  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE))
744    return DRE->getDecl();
745  if (MemberExpr *ME = dyn_cast<MemberExpr>(CEE))
746    return ME->getMemberDecl();
747
748  return 0;
749}
750
751FunctionDecl *CallExpr::getDirectCallee() {
752  return dyn_cast_or_null<FunctionDecl>(getCalleeDecl());
753}
754
755/// setNumArgs - This changes the number of arguments present in this call.
756/// Any orphaned expressions are deleted by this, and any new operands are set
757/// to null.
758void CallExpr::setNumArgs(ASTContext& C, unsigned NumArgs) {
759  // No change, just return.
760  if (NumArgs == getNumArgs()) return;
761
762  // If shrinking # arguments, just delete the extras and forgot them.
763  if (NumArgs < getNumArgs()) {
764    this->NumArgs = NumArgs;
765    return;
766  }
767
768  // Otherwise, we are growing the # arguments.  New an bigger argument array.
769  unsigned NumPreArgs = getNumPreArgs();
770  Stmt **NewSubExprs = new (C) Stmt*[NumArgs+PREARGS_START+NumPreArgs];
771  // Copy over args.
772  for (unsigned i = 0; i != getNumArgs()+PREARGS_START+NumPreArgs; ++i)
773    NewSubExprs[i] = SubExprs[i];
774  // Null out new args.
775  for (unsigned i = getNumArgs()+PREARGS_START+NumPreArgs;
776       i != NumArgs+PREARGS_START+NumPreArgs; ++i)
777    NewSubExprs[i] = 0;
778
779  if (SubExprs) C.Deallocate(SubExprs);
780  SubExprs = NewSubExprs;
781  this->NumArgs = NumArgs;
782}
783
784/// isBuiltinCall - If this is a call to a builtin, return the builtin ID.  If
785/// not, return 0.
786unsigned CallExpr::isBuiltinCall(const ASTContext &Context) const {
787  // All simple function calls (e.g. func()) are implicitly cast to pointer to
788  // function. As a result, we try and obtain the DeclRefExpr from the
789  // ImplicitCastExpr.
790  const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee());
791  if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()).
792    return 0;
793
794  const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
795  if (!DRE)
796    return 0;
797
798  const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl());
799  if (!FDecl)
800    return 0;
801
802  if (!FDecl->getIdentifier())
803    return 0;
804
805  return FDecl->getBuiltinID();
806}
807
808QualType CallExpr::getCallReturnType() const {
809  QualType CalleeType = getCallee()->getType();
810  if (const PointerType *FnTypePtr = CalleeType->getAs<PointerType>())
811    CalleeType = FnTypePtr->getPointeeType();
812  else if (const BlockPointerType *BPT = CalleeType->getAs<BlockPointerType>())
813    CalleeType = BPT->getPointeeType();
814  else if (CalleeType->isSpecificPlaceholderType(BuiltinType::BoundMember))
815    // This should never be overloaded and so should never return null.
816    CalleeType = Expr::findBoundMemberType(getCallee());
817
818  const FunctionType *FnType = CalleeType->castAs<FunctionType>();
819  return FnType->getResultType();
820}
821
822SourceRange CallExpr::getSourceRange() const {
823  if (isa<CXXOperatorCallExpr>(this))
824    return cast<CXXOperatorCallExpr>(this)->getSourceRange();
825
826  SourceLocation begin = getCallee()->getLocStart();
827  if (begin.isInvalid() && getNumArgs() > 0)
828    begin = getArg(0)->getLocStart();
829  SourceLocation end = getRParenLoc();
830  if (end.isInvalid() && getNumArgs() > 0)
831    end = getArg(getNumArgs() - 1)->getLocEnd();
832  return SourceRange(begin, end);
833}
834
835OffsetOfExpr *OffsetOfExpr::Create(ASTContext &C, QualType type,
836                                   SourceLocation OperatorLoc,
837                                   TypeSourceInfo *tsi,
838                                   OffsetOfNode* compsPtr, unsigned numComps,
839                                   Expr** exprsPtr, unsigned numExprs,
840                                   SourceLocation RParenLoc) {
841  void *Mem = C.Allocate(sizeof(OffsetOfExpr) +
842                         sizeof(OffsetOfNode) * numComps +
843                         sizeof(Expr*) * numExprs);
844
845  return new (Mem) OffsetOfExpr(C, type, OperatorLoc, tsi, compsPtr, numComps,
846                                exprsPtr, numExprs, RParenLoc);
847}
848
849OffsetOfExpr *OffsetOfExpr::CreateEmpty(ASTContext &C,
850                                        unsigned numComps, unsigned numExprs) {
851  void *Mem = C.Allocate(sizeof(OffsetOfExpr) +
852                         sizeof(OffsetOfNode) * numComps +
853                         sizeof(Expr*) * numExprs);
854  return new (Mem) OffsetOfExpr(numComps, numExprs);
855}
856
857OffsetOfExpr::OffsetOfExpr(ASTContext &C, QualType type,
858                           SourceLocation OperatorLoc, TypeSourceInfo *tsi,
859                           OffsetOfNode* compsPtr, unsigned numComps,
860                           Expr** exprsPtr, unsigned numExprs,
861                           SourceLocation RParenLoc)
862  : Expr(OffsetOfExprClass, type, VK_RValue, OK_Ordinary,
863         /*TypeDependent=*/false,
864         /*ValueDependent=*/tsi->getType()->isDependentType(),
865         tsi->getType()->containsUnexpandedParameterPack()),
866    OperatorLoc(OperatorLoc), RParenLoc(RParenLoc), TSInfo(tsi),
867    NumComps(numComps), NumExprs(numExprs)
868{
869  for(unsigned i = 0; i < numComps; ++i) {
870    setComponent(i, compsPtr[i]);
871  }
872
873  for(unsigned i = 0; i < numExprs; ++i) {
874    if (exprsPtr[i]->isTypeDependent() || exprsPtr[i]->isValueDependent())
875      ExprBits.ValueDependent = true;
876    if (exprsPtr[i]->containsUnexpandedParameterPack())
877      ExprBits.ContainsUnexpandedParameterPack = true;
878
879    setIndexExpr(i, exprsPtr[i]);
880  }
881}
882
883IdentifierInfo *OffsetOfExpr::OffsetOfNode::getFieldName() const {
884  assert(getKind() == Field || getKind() == Identifier);
885  if (getKind() == Field)
886    return getField()->getIdentifier();
887
888  return reinterpret_cast<IdentifierInfo *> (Data & ~(uintptr_t)Mask);
889}
890
891MemberExpr *MemberExpr::Create(ASTContext &C, Expr *base, bool isarrow,
892                               NestedNameSpecifierLoc QualifierLoc,
893                               ValueDecl *memberdecl,
894                               DeclAccessPair founddecl,
895                               DeclarationNameInfo nameinfo,
896                               const TemplateArgumentListInfo *targs,
897                               QualType ty,
898                               ExprValueKind vk,
899                               ExprObjectKind ok) {
900  std::size_t Size = sizeof(MemberExpr);
901
902  bool hasQualOrFound = (QualifierLoc ||
903                         founddecl.getDecl() != memberdecl ||
904                         founddecl.getAccess() != memberdecl->getAccess());
905  if (hasQualOrFound)
906    Size += sizeof(MemberNameQualifier);
907
908  if (targs)
909    Size += ExplicitTemplateArgumentList::sizeFor(*targs);
910
911  void *Mem = C.Allocate(Size, llvm::alignOf<MemberExpr>());
912  MemberExpr *E = new (Mem) MemberExpr(base, isarrow, memberdecl, nameinfo,
913                                       ty, vk, ok);
914
915  if (hasQualOrFound) {
916    // FIXME: Wrong. We should be looking at the member declaration we found.
917    if (QualifierLoc && QualifierLoc.getNestedNameSpecifier()->isDependent()) {
918      E->setValueDependent(true);
919      E->setTypeDependent(true);
920    }
921    E->HasQualifierOrFoundDecl = true;
922
923    MemberNameQualifier *NQ = E->getMemberQualifier();
924    NQ->QualifierLoc = QualifierLoc;
925    NQ->FoundDecl = founddecl;
926  }
927
928  if (targs) {
929    E->HasExplicitTemplateArgumentList = true;
930    E->getExplicitTemplateArgs().initializeFrom(*targs);
931  }
932
933  return E;
934}
935
936SourceRange MemberExpr::getSourceRange() const {
937  SourceLocation StartLoc;
938  if (isImplicitAccess()) {
939    if (hasQualifier())
940      StartLoc = getQualifierLoc().getBeginLoc();
941    else
942      StartLoc = MemberLoc;
943  } else {
944    // FIXME: We don't want this to happen. Rather, we should be able to
945    // detect all kinds of implicit accesses more cleanly.
946    StartLoc = getBase()->getLocStart();
947    if (StartLoc.isInvalid())
948      StartLoc = MemberLoc;
949  }
950
951  SourceLocation EndLoc =
952    HasExplicitTemplateArgumentList? getRAngleLoc()
953                                   : getMemberNameInfo().getEndLoc();
954
955  return SourceRange(StartLoc, EndLoc);
956}
957
958const char *CastExpr::getCastKindName() const {
959  switch (getCastKind()) {
960  case CK_Dependent:
961    return "Dependent";
962  case CK_BitCast:
963    return "BitCast";
964  case CK_LValueBitCast:
965    return "LValueBitCast";
966  case CK_LValueToRValue:
967    return "LValueToRValue";
968  case CK_GetObjCProperty:
969    return "GetObjCProperty";
970  case CK_NoOp:
971    return "NoOp";
972  case CK_BaseToDerived:
973    return "BaseToDerived";
974  case CK_DerivedToBase:
975    return "DerivedToBase";
976  case CK_UncheckedDerivedToBase:
977    return "UncheckedDerivedToBase";
978  case CK_Dynamic:
979    return "Dynamic";
980  case CK_ToUnion:
981    return "ToUnion";
982  case CK_ArrayToPointerDecay:
983    return "ArrayToPointerDecay";
984  case CK_FunctionToPointerDecay:
985    return "FunctionToPointerDecay";
986  case CK_NullToMemberPointer:
987    return "NullToMemberPointer";
988  case CK_NullToPointer:
989    return "NullToPointer";
990  case CK_BaseToDerivedMemberPointer:
991    return "BaseToDerivedMemberPointer";
992  case CK_DerivedToBaseMemberPointer:
993    return "DerivedToBaseMemberPointer";
994  case CK_UserDefinedConversion:
995    return "UserDefinedConversion";
996  case CK_ConstructorConversion:
997    return "ConstructorConversion";
998  case CK_IntegralToPointer:
999    return "IntegralToPointer";
1000  case CK_PointerToIntegral:
1001    return "PointerToIntegral";
1002  case CK_PointerToBoolean:
1003    return "PointerToBoolean";
1004  case CK_ToVoid:
1005    return "ToVoid";
1006  case CK_VectorSplat:
1007    return "VectorSplat";
1008  case CK_IntegralCast:
1009    return "IntegralCast";
1010  case CK_IntegralToBoolean:
1011    return "IntegralToBoolean";
1012  case CK_IntegralToFloating:
1013    return "IntegralToFloating";
1014  case CK_FloatingToIntegral:
1015    return "FloatingToIntegral";
1016  case CK_FloatingCast:
1017    return "FloatingCast";
1018  case CK_FloatingToBoolean:
1019    return "FloatingToBoolean";
1020  case CK_MemberPointerToBoolean:
1021    return "MemberPointerToBoolean";
1022  case CK_AnyPointerToObjCPointerCast:
1023    return "AnyPointerToObjCPointerCast";
1024  case CK_AnyPointerToBlockPointerCast:
1025    return "AnyPointerToBlockPointerCast";
1026  case CK_ObjCObjectLValueCast:
1027    return "ObjCObjectLValueCast";
1028  case CK_FloatingRealToComplex:
1029    return "FloatingRealToComplex";
1030  case CK_FloatingComplexToReal:
1031    return "FloatingComplexToReal";
1032  case CK_FloatingComplexToBoolean:
1033    return "FloatingComplexToBoolean";
1034  case CK_FloatingComplexCast:
1035    return "FloatingComplexCast";
1036  case CK_FloatingComplexToIntegralComplex:
1037    return "FloatingComplexToIntegralComplex";
1038  case CK_IntegralRealToComplex:
1039    return "IntegralRealToComplex";
1040  case CK_IntegralComplexToReal:
1041    return "IntegralComplexToReal";
1042  case CK_IntegralComplexToBoolean:
1043    return "IntegralComplexToBoolean";
1044  case CK_IntegralComplexCast:
1045    return "IntegralComplexCast";
1046  case CK_IntegralComplexToFloatingComplex:
1047    return "IntegralComplexToFloatingComplex";
1048  case CK_ObjCConsumeObject:
1049    return "ObjCConsumeObject";
1050  case CK_ObjCProduceObject:
1051    return "ObjCProduceObject";
1052  }
1053
1054  llvm_unreachable("Unhandled cast kind!");
1055  return 0;
1056}
1057
1058Expr *CastExpr::getSubExprAsWritten() {
1059  Expr *SubExpr = 0;
1060  CastExpr *E = this;
1061  do {
1062    SubExpr = E->getSubExpr();
1063
1064    // Skip any temporary bindings; they're implicit.
1065    if (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(SubExpr))
1066      SubExpr = Binder->getSubExpr();
1067
1068    // Conversions by constructor and conversion functions have a
1069    // subexpression describing the call; strip it off.
1070    if (E->getCastKind() == CK_ConstructorConversion)
1071      SubExpr = cast<CXXConstructExpr>(SubExpr)->getArg(0);
1072    else if (E->getCastKind() == CK_UserDefinedConversion)
1073      SubExpr = cast<CXXMemberCallExpr>(SubExpr)->getImplicitObjectArgument();
1074
1075    // If the subexpression we're left with is an implicit cast, look
1076    // through that, too.
1077  } while ((E = dyn_cast<ImplicitCastExpr>(SubExpr)));
1078
1079  return SubExpr;
1080}
1081
1082CXXBaseSpecifier **CastExpr::path_buffer() {
1083  switch (getStmtClass()) {
1084#define ABSTRACT_STMT(x)
1085#define CASTEXPR(Type, Base) \
1086  case Stmt::Type##Class: \
1087    return reinterpret_cast<CXXBaseSpecifier**>(static_cast<Type*>(this)+1);
1088#define STMT(Type, Base)
1089#include "clang/AST/StmtNodes.inc"
1090  default:
1091    llvm_unreachable("non-cast expressions not possible here");
1092    return 0;
1093  }
1094}
1095
1096void CastExpr::setCastPath(const CXXCastPath &Path) {
1097  assert(Path.size() == path_size());
1098  memcpy(path_buffer(), Path.data(), Path.size() * sizeof(CXXBaseSpecifier*));
1099}
1100
1101ImplicitCastExpr *ImplicitCastExpr::Create(ASTContext &C, QualType T,
1102                                           CastKind Kind, Expr *Operand,
1103                                           const CXXCastPath *BasePath,
1104                                           ExprValueKind VK) {
1105  unsigned PathSize = (BasePath ? BasePath->size() : 0);
1106  void *Buffer =
1107    C.Allocate(sizeof(ImplicitCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
1108  ImplicitCastExpr *E =
1109    new (Buffer) ImplicitCastExpr(T, Kind, Operand, PathSize, VK);
1110  if (PathSize) E->setCastPath(*BasePath);
1111  return E;
1112}
1113
1114ImplicitCastExpr *ImplicitCastExpr::CreateEmpty(ASTContext &C,
1115                                                unsigned PathSize) {
1116  void *Buffer =
1117    C.Allocate(sizeof(ImplicitCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
1118  return new (Buffer) ImplicitCastExpr(EmptyShell(), PathSize);
1119}
1120
1121
1122CStyleCastExpr *CStyleCastExpr::Create(ASTContext &C, QualType T,
1123                                       ExprValueKind VK, CastKind K, Expr *Op,
1124                                       const CXXCastPath *BasePath,
1125                                       TypeSourceInfo *WrittenTy,
1126                                       SourceLocation L, SourceLocation R) {
1127  unsigned PathSize = (BasePath ? BasePath->size() : 0);
1128  void *Buffer =
1129    C.Allocate(sizeof(CStyleCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
1130  CStyleCastExpr *E =
1131    new (Buffer) CStyleCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, R);
1132  if (PathSize) E->setCastPath(*BasePath);
1133  return E;
1134}
1135
1136CStyleCastExpr *CStyleCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) {
1137  void *Buffer =
1138    C.Allocate(sizeof(CStyleCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
1139  return new (Buffer) CStyleCastExpr(EmptyShell(), PathSize);
1140}
1141
1142/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
1143/// corresponds to, e.g. "<<=".
1144const char *BinaryOperator::getOpcodeStr(Opcode Op) {
1145  switch (Op) {
1146  case BO_PtrMemD:   return ".*";
1147  case BO_PtrMemI:   return "->*";
1148  case BO_Mul:       return "*";
1149  case BO_Div:       return "/";
1150  case BO_Rem:       return "%";
1151  case BO_Add:       return "+";
1152  case BO_Sub:       return "-";
1153  case BO_Shl:       return "<<";
1154  case BO_Shr:       return ">>";
1155  case BO_LT:        return "<";
1156  case BO_GT:        return ">";
1157  case BO_LE:        return "<=";
1158  case BO_GE:        return ">=";
1159  case BO_EQ:        return "==";
1160  case BO_NE:        return "!=";
1161  case BO_And:       return "&";
1162  case BO_Xor:       return "^";
1163  case BO_Or:        return "|";
1164  case BO_LAnd:      return "&&";
1165  case BO_LOr:       return "||";
1166  case BO_Assign:    return "=";
1167  case BO_MulAssign: return "*=";
1168  case BO_DivAssign: return "/=";
1169  case BO_RemAssign: return "%=";
1170  case BO_AddAssign: return "+=";
1171  case BO_SubAssign: return "-=";
1172  case BO_ShlAssign: return "<<=";
1173  case BO_ShrAssign: return ">>=";
1174  case BO_AndAssign: return "&=";
1175  case BO_XorAssign: return "^=";
1176  case BO_OrAssign:  return "|=";
1177  case BO_Comma:     return ",";
1178  }
1179
1180  return "";
1181}
1182
1183BinaryOperatorKind
1184BinaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO) {
1185  switch (OO) {
1186  default: assert(false && "Not an overloadable binary operator");
1187  case OO_Plus: return BO_Add;
1188  case OO_Minus: return BO_Sub;
1189  case OO_Star: return BO_Mul;
1190  case OO_Slash: return BO_Div;
1191  case OO_Percent: return BO_Rem;
1192  case OO_Caret: return BO_Xor;
1193  case OO_Amp: return BO_And;
1194  case OO_Pipe: return BO_Or;
1195  case OO_Equal: return BO_Assign;
1196  case OO_Less: return BO_LT;
1197  case OO_Greater: return BO_GT;
1198  case OO_PlusEqual: return BO_AddAssign;
1199  case OO_MinusEqual: return BO_SubAssign;
1200  case OO_StarEqual: return BO_MulAssign;
1201  case OO_SlashEqual: return BO_DivAssign;
1202  case OO_PercentEqual: return BO_RemAssign;
1203  case OO_CaretEqual: return BO_XorAssign;
1204  case OO_AmpEqual: return BO_AndAssign;
1205  case OO_PipeEqual: return BO_OrAssign;
1206  case OO_LessLess: return BO_Shl;
1207  case OO_GreaterGreater: return BO_Shr;
1208  case OO_LessLessEqual: return BO_ShlAssign;
1209  case OO_GreaterGreaterEqual: return BO_ShrAssign;
1210  case OO_EqualEqual: return BO_EQ;
1211  case OO_ExclaimEqual: return BO_NE;
1212  case OO_LessEqual: return BO_LE;
1213  case OO_GreaterEqual: return BO_GE;
1214  case OO_AmpAmp: return BO_LAnd;
1215  case OO_PipePipe: return BO_LOr;
1216  case OO_Comma: return BO_Comma;
1217  case OO_ArrowStar: return BO_PtrMemI;
1218  }
1219}
1220
1221OverloadedOperatorKind BinaryOperator::getOverloadedOperator(Opcode Opc) {
1222  static const OverloadedOperatorKind OverOps[] = {
1223    /* .* Cannot be overloaded */OO_None, OO_ArrowStar,
1224    OO_Star, OO_Slash, OO_Percent,
1225    OO_Plus, OO_Minus,
1226    OO_LessLess, OO_GreaterGreater,
1227    OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual,
1228    OO_EqualEqual, OO_ExclaimEqual,
1229    OO_Amp,
1230    OO_Caret,
1231    OO_Pipe,
1232    OO_AmpAmp,
1233    OO_PipePipe,
1234    OO_Equal, OO_StarEqual,
1235    OO_SlashEqual, OO_PercentEqual,
1236    OO_PlusEqual, OO_MinusEqual,
1237    OO_LessLessEqual, OO_GreaterGreaterEqual,
1238    OO_AmpEqual, OO_CaretEqual,
1239    OO_PipeEqual,
1240    OO_Comma
1241  };
1242  return OverOps[Opc];
1243}
1244
1245InitListExpr::InitListExpr(ASTContext &C, SourceLocation lbraceloc,
1246                           Expr **initExprs, unsigned numInits,
1247                           SourceLocation rbraceloc)
1248  : Expr(InitListExprClass, QualType(), VK_RValue, OK_Ordinary, false, false,
1249         false),
1250    InitExprs(C, numInits),
1251    LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), SyntacticForm(0),
1252    HadArrayRangeDesignator(false)
1253{
1254  for (unsigned I = 0; I != numInits; ++I) {
1255    if (initExprs[I]->isTypeDependent())
1256      ExprBits.TypeDependent = true;
1257    if (initExprs[I]->isValueDependent())
1258      ExprBits.ValueDependent = true;
1259    if (initExprs[I]->containsUnexpandedParameterPack())
1260      ExprBits.ContainsUnexpandedParameterPack = true;
1261  }
1262
1263  InitExprs.insert(C, InitExprs.end(), initExprs, initExprs+numInits);
1264}
1265
1266void InitListExpr::reserveInits(ASTContext &C, unsigned NumInits) {
1267  if (NumInits > InitExprs.size())
1268    InitExprs.reserve(C, NumInits);
1269}
1270
1271void InitListExpr::resizeInits(ASTContext &C, unsigned NumInits) {
1272  InitExprs.resize(C, NumInits, 0);
1273}
1274
1275Expr *InitListExpr::updateInit(ASTContext &C, unsigned Init, Expr *expr) {
1276  if (Init >= InitExprs.size()) {
1277    InitExprs.insert(C, InitExprs.end(), Init - InitExprs.size() + 1, 0);
1278    InitExprs.back() = expr;
1279    return 0;
1280  }
1281
1282  Expr *Result = cast_or_null<Expr>(InitExprs[Init]);
1283  InitExprs[Init] = expr;
1284  return Result;
1285}
1286
1287void InitListExpr::setArrayFiller(Expr *filler) {
1288  ArrayFillerOrUnionFieldInit = filler;
1289  // Fill out any "holes" in the array due to designated initializers.
1290  Expr **inits = getInits();
1291  for (unsigned i = 0, e = getNumInits(); i != e; ++i)
1292    if (inits[i] == 0)
1293      inits[i] = filler;
1294}
1295
1296SourceRange InitListExpr::getSourceRange() const {
1297  if (SyntacticForm)
1298    return SyntacticForm->getSourceRange();
1299  SourceLocation Beg = LBraceLoc, End = RBraceLoc;
1300  if (Beg.isInvalid()) {
1301    // Find the first non-null initializer.
1302    for (InitExprsTy::const_iterator I = InitExprs.begin(),
1303                                     E = InitExprs.end();
1304      I != E; ++I) {
1305      if (Stmt *S = *I) {
1306        Beg = S->getLocStart();
1307        break;
1308      }
1309    }
1310  }
1311  if (End.isInvalid()) {
1312    // Find the first non-null initializer from the end.
1313    for (InitExprsTy::const_reverse_iterator I = InitExprs.rbegin(),
1314                                             E = InitExprs.rend();
1315      I != E; ++I) {
1316      if (Stmt *S = *I) {
1317        End = S->getSourceRange().getEnd();
1318        break;
1319      }
1320    }
1321  }
1322  return SourceRange(Beg, End);
1323}
1324
1325/// getFunctionType - Return the underlying function type for this block.
1326///
1327const FunctionType *BlockExpr::getFunctionType() const {
1328  return getType()->getAs<BlockPointerType>()->
1329                    getPointeeType()->getAs<FunctionType>();
1330}
1331
1332SourceLocation BlockExpr::getCaretLocation() const {
1333  return TheBlock->getCaretLocation();
1334}
1335const Stmt *BlockExpr::getBody() const {
1336  return TheBlock->getBody();
1337}
1338Stmt *BlockExpr::getBody() {
1339  return TheBlock->getBody();
1340}
1341
1342
1343//===----------------------------------------------------------------------===//
1344// Generic Expression Routines
1345//===----------------------------------------------------------------------===//
1346
1347/// isUnusedResultAWarning - Return true if this immediate expression should
1348/// be warned about if the result is unused.  If so, fill in Loc and Ranges
1349/// with location to warn on and the source range[s] to report with the
1350/// warning.
1351bool Expr::isUnusedResultAWarning(SourceLocation &Loc, SourceRange &R1,
1352                                  SourceRange &R2, ASTContext &Ctx) const {
1353  // Don't warn if the expr is type dependent. The type could end up
1354  // instantiating to void.
1355  if (isTypeDependent())
1356    return false;
1357
1358  switch (getStmtClass()) {
1359  default:
1360    if (getType()->isVoidType())
1361      return false;
1362    Loc = getExprLoc();
1363    R1 = getSourceRange();
1364    return true;
1365  case ParenExprClass:
1366    return cast<ParenExpr>(this)->getSubExpr()->
1367      isUnusedResultAWarning(Loc, R1, R2, Ctx);
1368  case GenericSelectionExprClass:
1369    return cast<GenericSelectionExpr>(this)->getResultExpr()->
1370      isUnusedResultAWarning(Loc, R1, R2, Ctx);
1371  case UnaryOperatorClass: {
1372    const UnaryOperator *UO = cast<UnaryOperator>(this);
1373
1374    switch (UO->getOpcode()) {
1375    default: break;
1376    case UO_PostInc:
1377    case UO_PostDec:
1378    case UO_PreInc:
1379    case UO_PreDec:                 // ++/--
1380      return false;  // Not a warning.
1381    case UO_Deref:
1382      // Dereferencing a volatile pointer is a side-effect.
1383      if (Ctx.getCanonicalType(getType()).isVolatileQualified())
1384        return false;
1385      break;
1386    case UO_Real:
1387    case UO_Imag:
1388      // accessing a piece of a volatile complex is a side-effect.
1389      if (Ctx.getCanonicalType(UO->getSubExpr()->getType())
1390          .isVolatileQualified())
1391        return false;
1392      break;
1393    case UO_Extension:
1394      return UO->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx);
1395    }
1396    Loc = UO->getOperatorLoc();
1397    R1 = UO->getSubExpr()->getSourceRange();
1398    return true;
1399  }
1400  case BinaryOperatorClass: {
1401    const BinaryOperator *BO = cast<BinaryOperator>(this);
1402    switch (BO->getOpcode()) {
1403      default:
1404        break;
1405      // Consider the RHS of comma for side effects. LHS was checked by
1406      // Sema::CheckCommaOperands.
1407      case BO_Comma:
1408        // ((foo = <blah>), 0) is an idiom for hiding the result (and
1409        // lvalue-ness) of an assignment written in a macro.
1410        if (IntegerLiteral *IE =
1411              dyn_cast<IntegerLiteral>(BO->getRHS()->IgnoreParens()))
1412          if (IE->getValue() == 0)
1413            return false;
1414        return BO->getRHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx);
1415      // Consider '||', '&&' to have side effects if the LHS or RHS does.
1416      case BO_LAnd:
1417      case BO_LOr:
1418        if (!BO->getLHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx) ||
1419            !BO->getRHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx))
1420          return false;
1421        break;
1422    }
1423    if (BO->isAssignmentOp())
1424      return false;
1425    Loc = BO->getOperatorLoc();
1426    R1 = BO->getLHS()->getSourceRange();
1427    R2 = BO->getRHS()->getSourceRange();
1428    return true;
1429  }
1430  case CompoundAssignOperatorClass:
1431  case VAArgExprClass:
1432    return false;
1433
1434  case ConditionalOperatorClass: {
1435    // If only one of the LHS or RHS is a warning, the operator might
1436    // be being used for control flow. Only warn if both the LHS and
1437    // RHS are warnings.
1438    const ConditionalOperator *Exp = cast<ConditionalOperator>(this);
1439    if (!Exp->getRHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx))
1440      return false;
1441    if (!Exp->getLHS())
1442      return true;
1443    return Exp->getLHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx);
1444  }
1445
1446  case MemberExprClass:
1447    // If the base pointer or element is to a volatile pointer/field, accessing
1448    // it is a side effect.
1449    if (Ctx.getCanonicalType(getType()).isVolatileQualified())
1450      return false;
1451    Loc = cast<MemberExpr>(this)->getMemberLoc();
1452    R1 = SourceRange(Loc, Loc);
1453    R2 = cast<MemberExpr>(this)->getBase()->getSourceRange();
1454    return true;
1455
1456  case ArraySubscriptExprClass:
1457    // If the base pointer or element is to a volatile pointer/field, accessing
1458    // it is a side effect.
1459    if (Ctx.getCanonicalType(getType()).isVolatileQualified())
1460      return false;
1461    Loc = cast<ArraySubscriptExpr>(this)->getRBracketLoc();
1462    R1 = cast<ArraySubscriptExpr>(this)->getLHS()->getSourceRange();
1463    R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange();
1464    return true;
1465
1466  case CallExprClass:
1467  case CXXOperatorCallExprClass:
1468  case CXXMemberCallExprClass: {
1469    // If this is a direct call, get the callee.
1470    const CallExpr *CE = cast<CallExpr>(this);
1471    if (const Decl *FD = CE->getCalleeDecl()) {
1472      // If the callee has attribute pure, const, or warn_unused_result, warn
1473      // about it. void foo() { strlen("bar"); } should warn.
1474      //
1475      // Note: If new cases are added here, DiagnoseUnusedExprResult should be
1476      // updated to match for QoI.
1477      if (FD->getAttr<WarnUnusedResultAttr>() ||
1478          FD->getAttr<PureAttr>() || FD->getAttr<ConstAttr>()) {
1479        Loc = CE->getCallee()->getLocStart();
1480        R1 = CE->getCallee()->getSourceRange();
1481
1482        if (unsigned NumArgs = CE->getNumArgs())
1483          R2 = SourceRange(CE->getArg(0)->getLocStart(),
1484                           CE->getArg(NumArgs-1)->getLocEnd());
1485        return true;
1486      }
1487    }
1488    return false;
1489  }
1490
1491  case CXXTemporaryObjectExprClass:
1492  case CXXConstructExprClass:
1493    return false;
1494
1495  case ObjCMessageExprClass: {
1496    const ObjCMessageExpr *ME = cast<ObjCMessageExpr>(this);
1497    if (Ctx.getLangOptions().ObjCAutoRefCount &&
1498        ME->isInstanceMessage() &&
1499        !ME->getType()->isVoidType() &&
1500        ME->getSelector().getIdentifierInfoForSlot(0) &&
1501        ME->getSelector().getIdentifierInfoForSlot(0)
1502                                               ->getName().startswith("init")) {
1503      Loc = getExprLoc();
1504      R1 = ME->getSourceRange();
1505      return true;
1506    }
1507
1508    const ObjCMethodDecl *MD = ME->getMethodDecl();
1509    if (MD && MD->getAttr<WarnUnusedResultAttr>()) {
1510      Loc = getExprLoc();
1511      return true;
1512    }
1513    return false;
1514  }
1515
1516  case ObjCPropertyRefExprClass:
1517    Loc = getExprLoc();
1518    R1 = getSourceRange();
1519    return true;
1520
1521  case StmtExprClass: {
1522    // Statement exprs don't logically have side effects themselves, but are
1523    // sometimes used in macros in ways that give them a type that is unused.
1524    // For example ({ blah; foo(); }) will end up with a type if foo has a type.
1525    // however, if the result of the stmt expr is dead, we don't want to emit a
1526    // warning.
1527    const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt();
1528    if (!CS->body_empty()) {
1529      if (const Expr *E = dyn_cast<Expr>(CS->body_back()))
1530        return E->isUnusedResultAWarning(Loc, R1, R2, Ctx);
1531      if (const LabelStmt *Label = dyn_cast<LabelStmt>(CS->body_back()))
1532        if (const Expr *E = dyn_cast<Expr>(Label->getSubStmt()))
1533          return E->isUnusedResultAWarning(Loc, R1, R2, Ctx);
1534    }
1535
1536    if (getType()->isVoidType())
1537      return false;
1538    Loc = cast<StmtExpr>(this)->getLParenLoc();
1539    R1 = getSourceRange();
1540    return true;
1541  }
1542  case CStyleCastExprClass:
1543    // If this is an explicit cast to void, allow it.  People do this when they
1544    // think they know what they're doing :).
1545    if (getType()->isVoidType())
1546      return false;
1547    Loc = cast<CStyleCastExpr>(this)->getLParenLoc();
1548    R1 = cast<CStyleCastExpr>(this)->getSubExpr()->getSourceRange();
1549    return true;
1550  case CXXFunctionalCastExprClass: {
1551    if (getType()->isVoidType())
1552      return false;
1553    const CastExpr *CE = cast<CastExpr>(this);
1554
1555    // If this is a cast to void or a constructor conversion, check the operand.
1556    // Otherwise, the result of the cast is unused.
1557    if (CE->getCastKind() == CK_ToVoid ||
1558        CE->getCastKind() == CK_ConstructorConversion)
1559      return (cast<CastExpr>(this)->getSubExpr()
1560              ->isUnusedResultAWarning(Loc, R1, R2, Ctx));
1561    Loc = cast<CXXFunctionalCastExpr>(this)->getTypeBeginLoc();
1562    R1 = cast<CXXFunctionalCastExpr>(this)->getSubExpr()->getSourceRange();
1563    return true;
1564  }
1565
1566  case ImplicitCastExprClass:
1567    // Check the operand, since implicit casts are inserted by Sema
1568    return (cast<ImplicitCastExpr>(this)
1569            ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
1570
1571  case CXXDefaultArgExprClass:
1572    return (cast<CXXDefaultArgExpr>(this)
1573            ->getExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
1574
1575  case CXXNewExprClass:
1576    // FIXME: In theory, there might be new expressions that don't have side
1577    // effects (e.g. a placement new with an uninitialized POD).
1578  case CXXDeleteExprClass:
1579    return false;
1580  case CXXBindTemporaryExprClass:
1581    return (cast<CXXBindTemporaryExpr>(this)
1582            ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
1583  case ExprWithCleanupsClass:
1584    return (cast<ExprWithCleanups>(this)
1585            ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
1586  }
1587}
1588
1589/// isOBJCGCCandidate - Check if an expression is objc gc'able.
1590/// returns true, if it is; false otherwise.
1591bool Expr::isOBJCGCCandidate(ASTContext &Ctx) const {
1592  const Expr *E = IgnoreParens();
1593  switch (E->getStmtClass()) {
1594  default:
1595    return false;
1596  case ObjCIvarRefExprClass:
1597    return true;
1598  case Expr::UnaryOperatorClass:
1599    return cast<UnaryOperator>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
1600  case ImplicitCastExprClass:
1601    return cast<ImplicitCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
1602  case CStyleCastExprClass:
1603    return cast<CStyleCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
1604  case DeclRefExprClass: {
1605    const Decl *D = cast<DeclRefExpr>(E)->getDecl();
1606    if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1607      if (VD->hasGlobalStorage())
1608        return true;
1609      QualType T = VD->getType();
1610      // dereferencing to a  pointer is always a gc'able candidate,
1611      // unless it is __weak.
1612      return T->isPointerType() &&
1613             (Ctx.getObjCGCAttrKind(T) != Qualifiers::Weak);
1614    }
1615    return false;
1616  }
1617  case MemberExprClass: {
1618    const MemberExpr *M = cast<MemberExpr>(E);
1619    return M->getBase()->isOBJCGCCandidate(Ctx);
1620  }
1621  case ArraySubscriptExprClass:
1622    return cast<ArraySubscriptExpr>(E)->getBase()->isOBJCGCCandidate(Ctx);
1623  }
1624}
1625
1626bool Expr::isBoundMemberFunction(ASTContext &Ctx) const {
1627  if (isTypeDependent())
1628    return false;
1629  return ClassifyLValue(Ctx) == Expr::LV_MemberFunction;
1630}
1631
1632QualType Expr::findBoundMemberType(const Expr *expr) {
1633  assert(expr->getType()->isSpecificPlaceholderType(BuiltinType::BoundMember));
1634
1635  // Bound member expressions are always one of these possibilities:
1636  //   x->m      x.m      x->*y      x.*y
1637  // (possibly parenthesized)
1638
1639  expr = expr->IgnoreParens();
1640  if (const MemberExpr *mem = dyn_cast<MemberExpr>(expr)) {
1641    assert(isa<CXXMethodDecl>(mem->getMemberDecl()));
1642    return mem->getMemberDecl()->getType();
1643  }
1644
1645  if (const BinaryOperator *op = dyn_cast<BinaryOperator>(expr)) {
1646    QualType type = op->getRHS()->getType()->castAs<MemberPointerType>()
1647                      ->getPointeeType();
1648    assert(type->isFunctionType());
1649    return type;
1650  }
1651
1652  assert(isa<UnresolvedMemberExpr>(expr));
1653  return QualType();
1654}
1655
1656static Expr::CanThrowResult MergeCanThrow(Expr::CanThrowResult CT1,
1657                                          Expr::CanThrowResult CT2) {
1658  // CanThrowResult constants are ordered so that the maximum is the correct
1659  // merge result.
1660  return CT1 > CT2 ? CT1 : CT2;
1661}
1662
1663static Expr::CanThrowResult CanSubExprsThrow(ASTContext &C, const Expr *CE) {
1664  Expr *E = const_cast<Expr*>(CE);
1665  Expr::CanThrowResult R = Expr::CT_Cannot;
1666  for (Expr::child_range I = E->children(); I && R != Expr::CT_Can; ++I) {
1667    R = MergeCanThrow(R, cast<Expr>(*I)->CanThrow(C));
1668  }
1669  return R;
1670}
1671
1672static Expr::CanThrowResult CanCalleeThrow(ASTContext &Ctx, const Expr *E,
1673                                           const Decl *D,
1674                                           bool NullThrows = true) {
1675  if (!D)
1676    return NullThrows ? Expr::CT_Can : Expr::CT_Cannot;
1677
1678  // See if we can get a function type from the decl somehow.
1679  const ValueDecl *VD = dyn_cast<ValueDecl>(D);
1680  if (!VD) // If we have no clue what we're calling, assume the worst.
1681    return Expr::CT_Can;
1682
1683  // As an extension, we assume that __attribute__((nothrow)) functions don't
1684  // throw.
1685  if (isa<FunctionDecl>(D) && D->hasAttr<NoThrowAttr>())
1686    return Expr::CT_Cannot;
1687
1688  QualType T = VD->getType();
1689  const FunctionProtoType *FT;
1690  if ((FT = T->getAs<FunctionProtoType>())) {
1691  } else if (const PointerType *PT = T->getAs<PointerType>())
1692    FT = PT->getPointeeType()->getAs<FunctionProtoType>();
1693  else if (const ReferenceType *RT = T->getAs<ReferenceType>())
1694    FT = RT->getPointeeType()->getAs<FunctionProtoType>();
1695  else if (const MemberPointerType *MT = T->getAs<MemberPointerType>())
1696    FT = MT->getPointeeType()->getAs<FunctionProtoType>();
1697  else if (const BlockPointerType *BT = T->getAs<BlockPointerType>())
1698    FT = BT->getPointeeType()->getAs<FunctionProtoType>();
1699
1700  if (!FT)
1701    return Expr::CT_Can;
1702
1703  if (FT->getExceptionSpecType() == EST_Delayed) {
1704    assert(isa<CXXConstructorDecl>(D) &&
1705           "only constructor exception specs can be unknown");
1706    Ctx.getDiagnostics().Report(E->getLocStart(),
1707                                diag::err_exception_spec_unknown)
1708      << E->getSourceRange();
1709    return Expr::CT_Can;
1710  }
1711
1712  return FT->isNothrow(Ctx) ? Expr::CT_Cannot : Expr::CT_Can;
1713}
1714
1715static Expr::CanThrowResult CanDynamicCastThrow(const CXXDynamicCastExpr *DC) {
1716  if (DC->isTypeDependent())
1717    return Expr::CT_Dependent;
1718
1719  if (!DC->getTypeAsWritten()->isReferenceType())
1720    return Expr::CT_Cannot;
1721
1722  if (DC->getSubExpr()->isTypeDependent())
1723    return Expr::CT_Dependent;
1724
1725  return DC->getCastKind() == clang::CK_Dynamic? Expr::CT_Can : Expr::CT_Cannot;
1726}
1727
1728static Expr::CanThrowResult CanTypeidThrow(ASTContext &C,
1729                                           const CXXTypeidExpr *DC) {
1730  if (DC->isTypeOperand())
1731    return Expr::CT_Cannot;
1732
1733  Expr *Op = DC->getExprOperand();
1734  if (Op->isTypeDependent())
1735    return Expr::CT_Dependent;
1736
1737  const RecordType *RT = Op->getType()->getAs<RecordType>();
1738  if (!RT)
1739    return Expr::CT_Cannot;
1740
1741  if (!cast<CXXRecordDecl>(RT->getDecl())->isPolymorphic())
1742    return Expr::CT_Cannot;
1743
1744  if (Op->Classify(C).isPRValue())
1745    return Expr::CT_Cannot;
1746
1747  return Expr::CT_Can;
1748}
1749
1750Expr::CanThrowResult Expr::CanThrow(ASTContext &C) const {
1751  // C++ [expr.unary.noexcept]p3:
1752  //   [Can throw] if in a potentially-evaluated context the expression would
1753  //   contain:
1754  switch (getStmtClass()) {
1755  case CXXThrowExprClass:
1756    //   - a potentially evaluated throw-expression
1757    return CT_Can;
1758
1759  case CXXDynamicCastExprClass: {
1760    //   - a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1761    //     where T is a reference type, that requires a run-time check
1762    CanThrowResult CT = CanDynamicCastThrow(cast<CXXDynamicCastExpr>(this));
1763    if (CT == CT_Can)
1764      return CT;
1765    return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1766  }
1767
1768  case CXXTypeidExprClass:
1769    //   - a potentially evaluated typeid expression applied to a glvalue
1770    //     expression whose type is a polymorphic class type
1771    return CanTypeidThrow(C, cast<CXXTypeidExpr>(this));
1772
1773    //   - a potentially evaluated call to a function, member function, function
1774    //     pointer, or member function pointer that does not have a non-throwing
1775    //     exception-specification
1776  case CallExprClass:
1777  case CXXOperatorCallExprClass:
1778  case CXXMemberCallExprClass: {
1779    const CallExpr *CE = cast<CallExpr>(this);
1780    CanThrowResult CT;
1781    if (isTypeDependent())
1782      CT = CT_Dependent;
1783    else if (isa<CXXPseudoDestructorExpr>(CE->getCallee()->IgnoreParens()))
1784      CT = CT_Cannot;
1785    else
1786      CT = CanCalleeThrow(C, this, CE->getCalleeDecl());
1787    if (CT == CT_Can)
1788      return CT;
1789    return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1790  }
1791
1792  case CXXConstructExprClass:
1793  case CXXTemporaryObjectExprClass: {
1794    CanThrowResult CT = CanCalleeThrow(C, this,
1795        cast<CXXConstructExpr>(this)->getConstructor());
1796    if (CT == CT_Can)
1797      return CT;
1798    return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1799  }
1800
1801  case CXXNewExprClass: {
1802    CanThrowResult CT;
1803    if (isTypeDependent())
1804      CT = CT_Dependent;
1805    else
1806      CT = MergeCanThrow(
1807        CanCalleeThrow(C, this, cast<CXXNewExpr>(this)->getOperatorNew()),
1808        CanCalleeThrow(C, this, cast<CXXNewExpr>(this)->getConstructor(),
1809                       /*NullThrows*/false));
1810    if (CT == CT_Can)
1811      return CT;
1812    return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1813  }
1814
1815  case CXXDeleteExprClass: {
1816    CanThrowResult CT;
1817    QualType DTy = cast<CXXDeleteExpr>(this)->getDestroyedType();
1818    if (DTy.isNull() || DTy->isDependentType()) {
1819      CT = CT_Dependent;
1820    } else {
1821      CT = CanCalleeThrow(C, this,
1822                          cast<CXXDeleteExpr>(this)->getOperatorDelete());
1823      if (const RecordType *RT = DTy->getAs<RecordType>()) {
1824        const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1825        CT = MergeCanThrow(CT, CanCalleeThrow(C, this, RD->getDestructor()));
1826      }
1827      if (CT == CT_Can)
1828        return CT;
1829    }
1830    return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1831  }
1832
1833  case CXXBindTemporaryExprClass: {
1834    // The bound temporary has to be destroyed again, which might throw.
1835    CanThrowResult CT = CanCalleeThrow(C, this,
1836      cast<CXXBindTemporaryExpr>(this)->getTemporary()->getDestructor());
1837    if (CT == CT_Can)
1838      return CT;
1839    return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1840  }
1841
1842    // ObjC message sends are like function calls, but never have exception
1843    // specs.
1844  case ObjCMessageExprClass:
1845  case ObjCPropertyRefExprClass:
1846    return CT_Can;
1847
1848    // Many other things have subexpressions, so we have to test those.
1849    // Some are simple:
1850  case ParenExprClass:
1851  case MemberExprClass:
1852  case CXXReinterpretCastExprClass:
1853  case CXXConstCastExprClass:
1854  case ConditionalOperatorClass:
1855  case CompoundLiteralExprClass:
1856  case ExtVectorElementExprClass:
1857  case InitListExprClass:
1858  case DesignatedInitExprClass:
1859  case ParenListExprClass:
1860  case VAArgExprClass:
1861  case CXXDefaultArgExprClass:
1862  case ExprWithCleanupsClass:
1863  case ObjCIvarRefExprClass:
1864  case ObjCIsaExprClass:
1865  case ShuffleVectorExprClass:
1866    return CanSubExprsThrow(C, this);
1867
1868    // Some might be dependent for other reasons.
1869  case UnaryOperatorClass:
1870  case ArraySubscriptExprClass:
1871  case ImplicitCastExprClass:
1872  case CStyleCastExprClass:
1873  case CXXStaticCastExprClass:
1874  case CXXFunctionalCastExprClass:
1875  case BinaryOperatorClass:
1876  case CompoundAssignOperatorClass: {
1877    CanThrowResult CT = isTypeDependent() ? CT_Dependent : CT_Cannot;
1878    return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1879  }
1880
1881    // FIXME: We should handle StmtExpr, but that opens a MASSIVE can of worms.
1882  case StmtExprClass:
1883    return CT_Can;
1884
1885  case ChooseExprClass:
1886    if (isTypeDependent() || isValueDependent())
1887      return CT_Dependent;
1888    return cast<ChooseExpr>(this)->getChosenSubExpr(C)->CanThrow(C);
1889
1890  case GenericSelectionExprClass:
1891    if (cast<GenericSelectionExpr>(this)->isResultDependent())
1892      return CT_Dependent;
1893    return cast<GenericSelectionExpr>(this)->getResultExpr()->CanThrow(C);
1894
1895    // Some expressions are always dependent.
1896  case DependentScopeDeclRefExprClass:
1897  case CXXUnresolvedConstructExprClass:
1898  case CXXDependentScopeMemberExprClass:
1899    return CT_Dependent;
1900
1901  default:
1902    // All other expressions don't have subexpressions, or else they are
1903    // unevaluated.
1904    return CT_Cannot;
1905  }
1906}
1907
1908Expr* Expr::IgnoreParens() {
1909  Expr* E = this;
1910  while (true) {
1911    if (ParenExpr* P = dyn_cast<ParenExpr>(E)) {
1912      E = P->getSubExpr();
1913      continue;
1914    }
1915    if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
1916      if (P->getOpcode() == UO_Extension) {
1917        E = P->getSubExpr();
1918        continue;
1919      }
1920    }
1921    if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
1922      if (!P->isResultDependent()) {
1923        E = P->getResultExpr();
1924        continue;
1925      }
1926    }
1927    return E;
1928  }
1929}
1930
1931/// IgnoreParenCasts - Ignore parentheses and casts.  Strip off any ParenExpr
1932/// or CastExprs or ImplicitCastExprs, returning their operand.
1933Expr *Expr::IgnoreParenCasts() {
1934  Expr *E = this;
1935  while (true) {
1936    if (ParenExpr* P = dyn_cast<ParenExpr>(E)) {
1937      E = P->getSubExpr();
1938      continue;
1939    }
1940    if (CastExpr *P = dyn_cast<CastExpr>(E)) {
1941      E = P->getSubExpr();
1942      continue;
1943    }
1944    if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
1945      if (P->getOpcode() == UO_Extension) {
1946        E = P->getSubExpr();
1947        continue;
1948      }
1949    }
1950    if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
1951      if (!P->isResultDependent()) {
1952        E = P->getResultExpr();
1953        continue;
1954      }
1955    }
1956    return E;
1957  }
1958}
1959
1960/// IgnoreParenLValueCasts - Ignore parentheses and lvalue-to-rvalue
1961/// casts.  This is intended purely as a temporary workaround for code
1962/// that hasn't yet been rewritten to do the right thing about those
1963/// casts, and may disappear along with the last internal use.
1964Expr *Expr::IgnoreParenLValueCasts() {
1965  Expr *E = this;
1966  while (true) {
1967    if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
1968      E = P->getSubExpr();
1969      continue;
1970    } else if (CastExpr *P = dyn_cast<CastExpr>(E)) {
1971      if (P->getCastKind() == CK_LValueToRValue) {
1972        E = P->getSubExpr();
1973        continue;
1974      }
1975    } else if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
1976      if (P->getOpcode() == UO_Extension) {
1977        E = P->getSubExpr();
1978        continue;
1979      }
1980    } else if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
1981      if (!P->isResultDependent()) {
1982        E = P->getResultExpr();
1983        continue;
1984      }
1985    }
1986    break;
1987  }
1988  return E;
1989}
1990
1991Expr *Expr::IgnoreParenImpCasts() {
1992  Expr *E = this;
1993  while (true) {
1994    if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
1995      E = P->getSubExpr();
1996      continue;
1997    }
1998    if (ImplicitCastExpr *P = dyn_cast<ImplicitCastExpr>(E)) {
1999      E = P->getSubExpr();
2000      continue;
2001    }
2002    if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
2003      if (P->getOpcode() == UO_Extension) {
2004        E = P->getSubExpr();
2005        continue;
2006      }
2007    }
2008    if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
2009      if (!P->isResultDependent()) {
2010        E = P->getResultExpr();
2011        continue;
2012      }
2013    }
2014    return E;
2015  }
2016}
2017
2018Expr *Expr::IgnoreConversionOperator() {
2019  if (CXXMemberCallExpr *MCE = dyn_cast<CXXMemberCallExpr>(this)) {
2020    if (isa<CXXConversionDecl>(MCE->getMethodDecl()))
2021      return MCE->getImplicitObjectArgument();
2022  }
2023  return this;
2024}
2025
2026/// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the
2027/// value (including ptr->int casts of the same size).  Strip off any
2028/// ParenExpr or CastExprs, returning their operand.
2029Expr *Expr::IgnoreParenNoopCasts(ASTContext &Ctx) {
2030  Expr *E = this;
2031  while (true) {
2032    if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
2033      E = P->getSubExpr();
2034      continue;
2035    }
2036
2037    if (CastExpr *P = dyn_cast<CastExpr>(E)) {
2038      // We ignore integer <-> casts that are of the same width, ptr<->ptr and
2039      // ptr<->int casts of the same width.  We also ignore all identity casts.
2040      Expr *SE = P->getSubExpr();
2041
2042      if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) {
2043        E = SE;
2044        continue;
2045      }
2046
2047      if ((E->getType()->isPointerType() ||
2048           E->getType()->isIntegralType(Ctx)) &&
2049          (SE->getType()->isPointerType() ||
2050           SE->getType()->isIntegralType(Ctx)) &&
2051          Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) {
2052        E = SE;
2053        continue;
2054      }
2055    }
2056
2057    if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
2058      if (P->getOpcode() == UO_Extension) {
2059        E = P->getSubExpr();
2060        continue;
2061      }
2062    }
2063
2064    if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
2065      if (!P->isResultDependent()) {
2066        E = P->getResultExpr();
2067        continue;
2068      }
2069    }
2070
2071    return E;
2072  }
2073}
2074
2075bool Expr::isDefaultArgument() const {
2076  const Expr *E = this;
2077  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
2078    E = ICE->getSubExprAsWritten();
2079
2080  return isa<CXXDefaultArgExpr>(E);
2081}
2082
2083/// \brief Skip over any no-op casts and any temporary-binding
2084/// expressions.
2085static const Expr *skipTemporaryBindingsNoOpCastsAndParens(const Expr *E) {
2086  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
2087    if (ICE->getCastKind() == CK_NoOp)
2088      E = ICE->getSubExpr();
2089    else
2090      break;
2091  }
2092
2093  while (const CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(E))
2094    E = BE->getSubExpr();
2095
2096  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
2097    if (ICE->getCastKind() == CK_NoOp)
2098      E = ICE->getSubExpr();
2099    else
2100      break;
2101  }
2102
2103  return E->IgnoreParens();
2104}
2105
2106/// isTemporaryObject - Determines if this expression produces a
2107/// temporary of the given class type.
2108bool Expr::isTemporaryObject(ASTContext &C, const CXXRecordDecl *TempTy) const {
2109  if (!C.hasSameUnqualifiedType(getType(), C.getTypeDeclType(TempTy)))
2110    return false;
2111
2112  const Expr *E = skipTemporaryBindingsNoOpCastsAndParens(this);
2113
2114  // Temporaries are by definition pr-values of class type.
2115  if (!E->Classify(C).isPRValue()) {
2116    // In this context, property reference is a message call and is pr-value.
2117    if (!isa<ObjCPropertyRefExpr>(E))
2118      return false;
2119  }
2120
2121  // Black-list a few cases which yield pr-values of class type that don't
2122  // refer to temporaries of that type:
2123
2124  // - implicit derived-to-base conversions
2125  if (isa<ImplicitCastExpr>(E)) {
2126    switch (cast<ImplicitCastExpr>(E)->getCastKind()) {
2127    case CK_DerivedToBase:
2128    case CK_UncheckedDerivedToBase:
2129      return false;
2130    default:
2131      break;
2132    }
2133  }
2134
2135  // - member expressions (all)
2136  if (isa<MemberExpr>(E))
2137    return false;
2138
2139  // - opaque values (all)
2140  if (isa<OpaqueValueExpr>(E))
2141    return false;
2142
2143  return true;
2144}
2145
2146bool Expr::isImplicitCXXThis() const {
2147  const Expr *E = this;
2148
2149  // Strip away parentheses and casts we don't care about.
2150  while (true) {
2151    if (const ParenExpr *Paren = dyn_cast<ParenExpr>(E)) {
2152      E = Paren->getSubExpr();
2153      continue;
2154    }
2155
2156    if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
2157      if (ICE->getCastKind() == CK_NoOp ||
2158          ICE->getCastKind() == CK_LValueToRValue ||
2159          ICE->getCastKind() == CK_DerivedToBase ||
2160          ICE->getCastKind() == CK_UncheckedDerivedToBase) {
2161        E = ICE->getSubExpr();
2162        continue;
2163      }
2164    }
2165
2166    if (const UnaryOperator* UnOp = dyn_cast<UnaryOperator>(E)) {
2167      if (UnOp->getOpcode() == UO_Extension) {
2168        E = UnOp->getSubExpr();
2169        continue;
2170      }
2171    }
2172
2173    break;
2174  }
2175
2176  if (const CXXThisExpr *This = dyn_cast<CXXThisExpr>(E))
2177    return This->isImplicit();
2178
2179  return false;
2180}
2181
2182/// hasAnyTypeDependentArguments - Determines if any of the expressions
2183/// in Exprs is type-dependent.
2184bool Expr::hasAnyTypeDependentArguments(Expr** Exprs, unsigned NumExprs) {
2185  for (unsigned I = 0; I < NumExprs; ++I)
2186    if (Exprs[I]->isTypeDependent())
2187      return true;
2188
2189  return false;
2190}
2191
2192/// hasAnyValueDependentArguments - Determines if any of the expressions
2193/// in Exprs is value-dependent.
2194bool Expr::hasAnyValueDependentArguments(Expr** Exprs, unsigned NumExprs) {
2195  for (unsigned I = 0; I < NumExprs; ++I)
2196    if (Exprs[I]->isValueDependent())
2197      return true;
2198
2199  return false;
2200}
2201
2202bool Expr::isConstantInitializer(ASTContext &Ctx, bool IsForRef) const {
2203  // This function is attempting whether an expression is an initializer
2204  // which can be evaluated at compile-time.  isEvaluatable handles most
2205  // of the cases, but it can't deal with some initializer-specific
2206  // expressions, and it can't deal with aggregates; we deal with those here,
2207  // and fall back to isEvaluatable for the other cases.
2208
2209  // If we ever capture reference-binding directly in the AST, we can
2210  // kill the second parameter.
2211
2212  if (IsForRef) {
2213    EvalResult Result;
2214    return EvaluateAsLValue(Result, Ctx) && !Result.HasSideEffects;
2215  }
2216
2217  switch (getStmtClass()) {
2218  default: break;
2219  case StringLiteralClass:
2220  case ObjCStringLiteralClass:
2221  case ObjCEncodeExprClass:
2222    return true;
2223  case CXXTemporaryObjectExprClass:
2224  case CXXConstructExprClass: {
2225    const CXXConstructExpr *CE = cast<CXXConstructExpr>(this);
2226
2227    // Only if it's
2228    // 1) an application of the trivial default constructor or
2229    if (!CE->getConstructor()->isTrivial()) return false;
2230    if (!CE->getNumArgs()) return true;
2231
2232    // 2) an elidable trivial copy construction of an operand which is
2233    //    itself a constant initializer.  Note that we consider the
2234    //    operand on its own, *not* as a reference binding.
2235    return CE->isElidable() &&
2236           CE->getArg(0)->isConstantInitializer(Ctx, false);
2237  }
2238  case CompoundLiteralExprClass: {
2239    // This handles gcc's extension that allows global initializers like
2240    // "struct x {int x;} x = (struct x) {};".
2241    // FIXME: This accepts other cases it shouldn't!
2242    const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer();
2243    return Exp->isConstantInitializer(Ctx, false);
2244  }
2245  case InitListExprClass: {
2246    // FIXME: This doesn't deal with fields with reference types correctly.
2247    // FIXME: This incorrectly allows pointers cast to integers to be assigned
2248    // to bitfields.
2249    const InitListExpr *Exp = cast<InitListExpr>(this);
2250    unsigned numInits = Exp->getNumInits();
2251    for (unsigned i = 0; i < numInits; i++) {
2252      if (!Exp->getInit(i)->isConstantInitializer(Ctx, false))
2253        return false;
2254    }
2255    return true;
2256  }
2257  case ImplicitValueInitExprClass:
2258    return true;
2259  case ParenExprClass:
2260    return cast<ParenExpr>(this)->getSubExpr()
2261      ->isConstantInitializer(Ctx, IsForRef);
2262  case GenericSelectionExprClass:
2263    if (cast<GenericSelectionExpr>(this)->isResultDependent())
2264      return false;
2265    return cast<GenericSelectionExpr>(this)->getResultExpr()
2266      ->isConstantInitializer(Ctx, IsForRef);
2267  case ChooseExprClass:
2268    return cast<ChooseExpr>(this)->getChosenSubExpr(Ctx)
2269      ->isConstantInitializer(Ctx, IsForRef);
2270  case UnaryOperatorClass: {
2271    const UnaryOperator* Exp = cast<UnaryOperator>(this);
2272    if (Exp->getOpcode() == UO_Extension)
2273      return Exp->getSubExpr()->isConstantInitializer(Ctx, false);
2274    break;
2275  }
2276  case BinaryOperatorClass: {
2277    // Special case &&foo - &&bar.  It would be nice to generalize this somehow
2278    // but this handles the common case.
2279    const BinaryOperator *Exp = cast<BinaryOperator>(this);
2280    if (Exp->getOpcode() == BO_Sub &&
2281        isa<AddrLabelExpr>(Exp->getLHS()->IgnoreParenNoopCasts(Ctx)) &&
2282        isa<AddrLabelExpr>(Exp->getRHS()->IgnoreParenNoopCasts(Ctx)))
2283      return true;
2284    break;
2285  }
2286  case CXXFunctionalCastExprClass:
2287  case CXXStaticCastExprClass:
2288  case ImplicitCastExprClass:
2289  case CStyleCastExprClass:
2290    // Handle casts with a destination that's a struct or union; this
2291    // deals with both the gcc no-op struct cast extension and the
2292    // cast-to-union extension.
2293    if (getType()->isRecordType())
2294      return cast<CastExpr>(this)->getSubExpr()
2295        ->isConstantInitializer(Ctx, false);
2296
2297    // Integer->integer casts can be handled here, which is important for
2298    // things like (int)(&&x-&&y).  Scary but true.
2299    if (getType()->isIntegerType() &&
2300        cast<CastExpr>(this)->getSubExpr()->getType()->isIntegerType())
2301      return cast<CastExpr>(this)->getSubExpr()
2302        ->isConstantInitializer(Ctx, false);
2303
2304    break;
2305  }
2306  return isEvaluatable(Ctx);
2307}
2308
2309/// isNullPointerConstant - C99 6.3.2.3p3 - Return whether this is a null
2310/// pointer constant or not, as well as the specific kind of constant detected.
2311/// Null pointer constants can be integer constant expressions with the
2312/// value zero, casts of zero to void*, nullptr (C++0X), or __null
2313/// (a GNU extension).
2314Expr::NullPointerConstantKind
2315Expr::isNullPointerConstant(ASTContext &Ctx,
2316                            NullPointerConstantValueDependence NPC) const {
2317  if (isValueDependent()) {
2318    switch (NPC) {
2319    case NPC_NeverValueDependent:
2320      assert(false && "Unexpected value dependent expression!");
2321      // If the unthinkable happens, fall through to the safest alternative.
2322
2323    case NPC_ValueDependentIsNull:
2324      if (isTypeDependent() || getType()->isIntegralType(Ctx))
2325        return NPCK_ZeroInteger;
2326      else
2327        return NPCK_NotNull;
2328
2329    case NPC_ValueDependentIsNotNull:
2330      return NPCK_NotNull;
2331    }
2332  }
2333
2334  // Strip off a cast to void*, if it exists. Except in C++.
2335  if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
2336    if (!Ctx.getLangOptions().CPlusPlus) {
2337      // Check that it is a cast to void*.
2338      if (const PointerType *PT = CE->getType()->getAs<PointerType>()) {
2339        QualType Pointee = PT->getPointeeType();
2340        if (!Pointee.hasQualifiers() &&
2341            Pointee->isVoidType() &&                              // to void*
2342            CE->getSubExpr()->getType()->isIntegerType())         // from int.
2343          return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
2344      }
2345    }
2346  } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
2347    // Ignore the ImplicitCastExpr type entirely.
2348    return ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
2349  } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
2350    // Accept ((void*)0) as a null pointer constant, as many other
2351    // implementations do.
2352    return PE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
2353  } else if (const GenericSelectionExpr *GE =
2354               dyn_cast<GenericSelectionExpr>(this)) {
2355    return GE->getResultExpr()->isNullPointerConstant(Ctx, NPC);
2356  } else if (const CXXDefaultArgExpr *DefaultArg
2357               = dyn_cast<CXXDefaultArgExpr>(this)) {
2358    // See through default argument expressions
2359    return DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC);
2360  } else if (isa<GNUNullExpr>(this)) {
2361    // The GNU __null extension is always a null pointer constant.
2362    return NPCK_GNUNull;
2363  }
2364
2365  // C++0x nullptr_t is always a null pointer constant.
2366  if (getType()->isNullPtrType())
2367    return NPCK_CXX0X_nullptr;
2368
2369  if (const RecordType *UT = getType()->getAsUnionType())
2370    if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>())
2371      if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(this)){
2372        const Expr *InitExpr = CLE->getInitializer();
2373        if (const InitListExpr *ILE = dyn_cast<InitListExpr>(InitExpr))
2374          return ILE->getInit(0)->isNullPointerConstant(Ctx, NPC);
2375      }
2376  // This expression must be an integer type.
2377  if (!getType()->isIntegerType() ||
2378      (Ctx.getLangOptions().CPlusPlus && getType()->isEnumeralType()))
2379    return NPCK_NotNull;
2380
2381  // If we have an integer constant expression, we need to *evaluate* it and
2382  // test for the value 0.
2383  llvm::APSInt Result;
2384  bool IsNull = isIntegerConstantExpr(Result, Ctx) && Result == 0;
2385
2386  return (IsNull ? NPCK_ZeroInteger : NPCK_NotNull);
2387}
2388
2389/// \brief If this expression is an l-value for an Objective C
2390/// property, find the underlying property reference expression.
2391const ObjCPropertyRefExpr *Expr::getObjCProperty() const {
2392  const Expr *E = this;
2393  while (true) {
2394    assert((E->getValueKind() == VK_LValue &&
2395            E->getObjectKind() == OK_ObjCProperty) &&
2396           "expression is not a property reference");
2397    E = E->IgnoreParenCasts();
2398    if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
2399      if (BO->getOpcode() == BO_Comma) {
2400        E = BO->getRHS();
2401        continue;
2402      }
2403    }
2404
2405    break;
2406  }
2407
2408  return cast<ObjCPropertyRefExpr>(E);
2409}
2410
2411FieldDecl *Expr::getBitField() {
2412  Expr *E = this->IgnoreParens();
2413
2414  while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
2415    if (ICE->getCastKind() == CK_LValueToRValue ||
2416        (ICE->getValueKind() != VK_RValue && ICE->getCastKind() == CK_NoOp))
2417      E = ICE->getSubExpr()->IgnoreParens();
2418    else
2419      break;
2420  }
2421
2422  if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
2423    if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
2424      if (Field->isBitField())
2425        return Field;
2426
2427  if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E))
2428    if (FieldDecl *Field = dyn_cast<FieldDecl>(DeclRef->getDecl()))
2429      if (Field->isBitField())
2430        return Field;
2431
2432  if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(E))
2433    if (BinOp->isAssignmentOp() && BinOp->getLHS())
2434      return BinOp->getLHS()->getBitField();
2435
2436  return 0;
2437}
2438
2439bool Expr::refersToVectorElement() const {
2440  const Expr *E = this->IgnoreParens();
2441
2442  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
2443    if (ICE->getValueKind() != VK_RValue &&
2444        ICE->getCastKind() == CK_NoOp)
2445      E = ICE->getSubExpr()->IgnoreParens();
2446    else
2447      break;
2448  }
2449
2450  if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E))
2451    return ASE->getBase()->getType()->isVectorType();
2452
2453  if (isa<ExtVectorElementExpr>(E))
2454    return true;
2455
2456  return false;
2457}
2458
2459/// isArrow - Return true if the base expression is a pointer to vector,
2460/// return false if the base expression is a vector.
2461bool ExtVectorElementExpr::isArrow() const {
2462  return getBase()->getType()->isPointerType();
2463}
2464
2465unsigned ExtVectorElementExpr::getNumElements() const {
2466  if (const VectorType *VT = getType()->getAs<VectorType>())
2467    return VT->getNumElements();
2468  return 1;
2469}
2470
2471/// containsDuplicateElements - Return true if any element access is repeated.
2472bool ExtVectorElementExpr::containsDuplicateElements() const {
2473  // FIXME: Refactor this code to an accessor on the AST node which returns the
2474  // "type" of component access, and share with code below and in Sema.
2475  llvm::StringRef Comp = Accessor->getName();
2476
2477  // Halving swizzles do not contain duplicate elements.
2478  if (Comp == "hi" || Comp == "lo" || Comp == "even" || Comp == "odd")
2479    return false;
2480
2481  // Advance past s-char prefix on hex swizzles.
2482  if (Comp[0] == 's' || Comp[0] == 'S')
2483    Comp = Comp.substr(1);
2484
2485  for (unsigned i = 0, e = Comp.size(); i != e; ++i)
2486    if (Comp.substr(i + 1).find(Comp[i]) != llvm::StringRef::npos)
2487        return true;
2488
2489  return false;
2490}
2491
2492/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray.
2493void ExtVectorElementExpr::getEncodedElementAccess(
2494                                  llvm::SmallVectorImpl<unsigned> &Elts) const {
2495  llvm::StringRef Comp = Accessor->getName();
2496  if (Comp[0] == 's' || Comp[0] == 'S')
2497    Comp = Comp.substr(1);
2498
2499  bool isHi =   Comp == "hi";
2500  bool isLo =   Comp == "lo";
2501  bool isEven = Comp == "even";
2502  bool isOdd  = Comp == "odd";
2503
2504  for (unsigned i = 0, e = getNumElements(); i != e; ++i) {
2505    uint64_t Index;
2506
2507    if (isHi)
2508      Index = e + i;
2509    else if (isLo)
2510      Index = i;
2511    else if (isEven)
2512      Index = 2 * i;
2513    else if (isOdd)
2514      Index = 2 * i + 1;
2515    else
2516      Index = ExtVectorType::getAccessorIdx(Comp[i]);
2517
2518    Elts.push_back(Index);
2519  }
2520}
2521
2522ObjCMessageExpr::ObjCMessageExpr(QualType T,
2523                                 ExprValueKind VK,
2524                                 SourceLocation LBracLoc,
2525                                 SourceLocation SuperLoc,
2526                                 bool IsInstanceSuper,
2527                                 QualType SuperType,
2528                                 Selector Sel,
2529                                 SourceLocation SelLoc,
2530                                 ObjCMethodDecl *Method,
2531                                 Expr **Args, unsigned NumArgs,
2532                                 SourceLocation RBracLoc)
2533  : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary,
2534         /*TypeDependent=*/false, /*ValueDependent=*/false,
2535         /*ContainsUnexpandedParameterPack=*/false),
2536    NumArgs(NumArgs), Kind(IsInstanceSuper? SuperInstance : SuperClass),
2537    HasMethod(Method != 0), IsDelegateInitCall(false), SuperLoc(SuperLoc),
2538    SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
2539                                                       : Sel.getAsOpaquePtr())),
2540    SelectorLoc(SelLoc), LBracLoc(LBracLoc), RBracLoc(RBracLoc)
2541{
2542  setReceiverPointer(SuperType.getAsOpaquePtr());
2543  if (NumArgs)
2544    memcpy(getArgs(), Args, NumArgs * sizeof(Expr *));
2545}
2546
2547ObjCMessageExpr::ObjCMessageExpr(QualType T,
2548                                 ExprValueKind VK,
2549                                 SourceLocation LBracLoc,
2550                                 TypeSourceInfo *Receiver,
2551                                 Selector Sel,
2552                                 SourceLocation SelLoc,
2553                                 ObjCMethodDecl *Method,
2554                                 Expr **Args, unsigned NumArgs,
2555                                 SourceLocation RBracLoc)
2556  : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, T->isDependentType(),
2557         T->isDependentType(), T->containsUnexpandedParameterPack()),
2558    NumArgs(NumArgs), Kind(Class),
2559    HasMethod(Method != 0), IsDelegateInitCall(false),
2560    SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
2561                                                       : Sel.getAsOpaquePtr())),
2562    SelectorLoc(SelLoc), LBracLoc(LBracLoc), RBracLoc(RBracLoc)
2563{
2564  setReceiverPointer(Receiver);
2565  Expr **MyArgs = getArgs();
2566  for (unsigned I = 0; I != NumArgs; ++I) {
2567    if (Args[I]->isTypeDependent())
2568      ExprBits.TypeDependent = true;
2569    if (Args[I]->isValueDependent())
2570      ExprBits.ValueDependent = true;
2571    if (Args[I]->containsUnexpandedParameterPack())
2572      ExprBits.ContainsUnexpandedParameterPack = true;
2573
2574    MyArgs[I] = Args[I];
2575  }
2576}
2577
2578ObjCMessageExpr::ObjCMessageExpr(QualType T,
2579                                 ExprValueKind VK,
2580                                 SourceLocation LBracLoc,
2581                                 Expr *Receiver,
2582                                 Selector Sel,
2583                                 SourceLocation SelLoc,
2584                                 ObjCMethodDecl *Method,
2585                                 Expr **Args, unsigned NumArgs,
2586                                 SourceLocation RBracLoc)
2587  : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, Receiver->isTypeDependent(),
2588         Receiver->isTypeDependent(),
2589         Receiver->containsUnexpandedParameterPack()),
2590    NumArgs(NumArgs), Kind(Instance),
2591    HasMethod(Method != 0), IsDelegateInitCall(false),
2592    SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
2593                                                       : Sel.getAsOpaquePtr())),
2594    SelectorLoc(SelLoc), LBracLoc(LBracLoc), RBracLoc(RBracLoc)
2595{
2596  setReceiverPointer(Receiver);
2597  Expr **MyArgs = getArgs();
2598  for (unsigned I = 0; I != NumArgs; ++I) {
2599    if (Args[I]->isTypeDependent())
2600      ExprBits.TypeDependent = true;
2601    if (Args[I]->isValueDependent())
2602      ExprBits.ValueDependent = true;
2603    if (Args[I]->containsUnexpandedParameterPack())
2604      ExprBits.ContainsUnexpandedParameterPack = true;
2605
2606    MyArgs[I] = Args[I];
2607  }
2608}
2609
2610ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
2611                                         ExprValueKind VK,
2612                                         SourceLocation LBracLoc,
2613                                         SourceLocation SuperLoc,
2614                                         bool IsInstanceSuper,
2615                                         QualType SuperType,
2616                                         Selector Sel,
2617                                         SourceLocation SelLoc,
2618                                         ObjCMethodDecl *Method,
2619                                         Expr **Args, unsigned NumArgs,
2620                                         SourceLocation RBracLoc) {
2621  unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
2622    NumArgs * sizeof(Expr *);
2623  void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment);
2624  return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, SuperLoc, IsInstanceSuper,
2625                                   SuperType, Sel, SelLoc, Method, Args,NumArgs,
2626                                   RBracLoc);
2627}
2628
2629ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
2630                                         ExprValueKind VK,
2631                                         SourceLocation LBracLoc,
2632                                         TypeSourceInfo *Receiver,
2633                                         Selector Sel,
2634                                         SourceLocation SelLoc,
2635                                         ObjCMethodDecl *Method,
2636                                         Expr **Args, unsigned NumArgs,
2637                                         SourceLocation RBracLoc) {
2638  unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
2639    NumArgs * sizeof(Expr *);
2640  void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment);
2641  return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, Receiver, Sel, SelLoc,
2642                                   Method, Args, NumArgs, RBracLoc);
2643}
2644
2645ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
2646                                         ExprValueKind VK,
2647                                         SourceLocation LBracLoc,
2648                                         Expr *Receiver,
2649                                         Selector Sel,
2650                                         SourceLocation SelLoc,
2651                                         ObjCMethodDecl *Method,
2652                                         Expr **Args, unsigned NumArgs,
2653                                         SourceLocation RBracLoc) {
2654  unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
2655    NumArgs * sizeof(Expr *);
2656  void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment);
2657  return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, Receiver, Sel, SelLoc,
2658                                   Method, Args, NumArgs, RBracLoc);
2659}
2660
2661ObjCMessageExpr *ObjCMessageExpr::CreateEmpty(ASTContext &Context,
2662                                              unsigned NumArgs) {
2663  unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
2664    NumArgs * sizeof(Expr *);
2665  void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment);
2666  return new (Mem) ObjCMessageExpr(EmptyShell(), NumArgs);
2667}
2668
2669SourceRange ObjCMessageExpr::getReceiverRange() const {
2670  switch (getReceiverKind()) {
2671  case Instance:
2672    return getInstanceReceiver()->getSourceRange();
2673
2674  case Class:
2675    return getClassReceiverTypeInfo()->getTypeLoc().getSourceRange();
2676
2677  case SuperInstance:
2678  case SuperClass:
2679    return getSuperLoc();
2680  }
2681
2682  return SourceLocation();
2683}
2684
2685Selector ObjCMessageExpr::getSelector() const {
2686  if (HasMethod)
2687    return reinterpret_cast<const ObjCMethodDecl *>(SelectorOrMethod)
2688                                                               ->getSelector();
2689  return Selector(SelectorOrMethod);
2690}
2691
2692ObjCInterfaceDecl *ObjCMessageExpr::getReceiverInterface() const {
2693  switch (getReceiverKind()) {
2694  case Instance:
2695    if (const ObjCObjectPointerType *Ptr
2696          = getInstanceReceiver()->getType()->getAs<ObjCObjectPointerType>())
2697      return Ptr->getInterfaceDecl();
2698    break;
2699
2700  case Class:
2701    if (const ObjCObjectType *Ty
2702          = getClassReceiver()->getAs<ObjCObjectType>())
2703      return Ty->getInterface();
2704    break;
2705
2706  case SuperInstance:
2707    if (const ObjCObjectPointerType *Ptr
2708          = getSuperType()->getAs<ObjCObjectPointerType>())
2709      return Ptr->getInterfaceDecl();
2710    break;
2711
2712  case SuperClass:
2713    if (const ObjCObjectType *Iface
2714          = getSuperType()->getAs<ObjCObjectType>())
2715      return Iface->getInterface();
2716    break;
2717  }
2718
2719  return 0;
2720}
2721
2722llvm::StringRef ObjCBridgedCastExpr::getBridgeKindName() const {
2723  switch (getBridgeKind()) {
2724  case OBC_Bridge:
2725    return "__bridge";
2726  case OBC_BridgeTransfer:
2727    return "__bridge_transfer";
2728  case OBC_BridgeRetained:
2729    return "__bridge_retained";
2730  }
2731
2732  return "__bridge";
2733}
2734
2735bool ChooseExpr::isConditionTrue(const ASTContext &C) const {
2736  return getCond()->EvaluateAsInt(C) != 0;
2737}
2738
2739ShuffleVectorExpr::ShuffleVectorExpr(ASTContext &C, Expr **args, unsigned nexpr,
2740                                     QualType Type, SourceLocation BLoc,
2741                                     SourceLocation RP)
2742   : Expr(ShuffleVectorExprClass, Type, VK_RValue, OK_Ordinary,
2743          Type->isDependentType(), Type->isDependentType(),
2744          Type->containsUnexpandedParameterPack()),
2745     BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(nexpr)
2746{
2747  SubExprs = new (C) Stmt*[nexpr];
2748  for (unsigned i = 0; i < nexpr; i++) {
2749    if (args[i]->isTypeDependent())
2750      ExprBits.TypeDependent = true;
2751    if (args[i]->isValueDependent())
2752      ExprBits.ValueDependent = true;
2753    if (args[i]->containsUnexpandedParameterPack())
2754      ExprBits.ContainsUnexpandedParameterPack = true;
2755
2756    SubExprs[i] = args[i];
2757  }
2758}
2759
2760void ShuffleVectorExpr::setExprs(ASTContext &C, Expr ** Exprs,
2761                                 unsigned NumExprs) {
2762  if (SubExprs) C.Deallocate(SubExprs);
2763
2764  SubExprs = new (C) Stmt* [NumExprs];
2765  this->NumExprs = NumExprs;
2766  memcpy(SubExprs, Exprs, sizeof(Expr *) * NumExprs);
2767}
2768
2769GenericSelectionExpr::GenericSelectionExpr(ASTContext &Context,
2770                               SourceLocation GenericLoc, Expr *ControllingExpr,
2771                               TypeSourceInfo **AssocTypes, Expr **AssocExprs,
2772                               unsigned NumAssocs, SourceLocation DefaultLoc,
2773                               SourceLocation RParenLoc,
2774                               bool ContainsUnexpandedParameterPack,
2775                               unsigned ResultIndex)
2776  : Expr(GenericSelectionExprClass,
2777         AssocExprs[ResultIndex]->getType(),
2778         AssocExprs[ResultIndex]->getValueKind(),
2779         AssocExprs[ResultIndex]->getObjectKind(),
2780         AssocExprs[ResultIndex]->isTypeDependent(),
2781         AssocExprs[ResultIndex]->isValueDependent(),
2782         ContainsUnexpandedParameterPack),
2783    AssocTypes(new (Context) TypeSourceInfo*[NumAssocs]),
2784    SubExprs(new (Context) Stmt*[END_EXPR+NumAssocs]), NumAssocs(NumAssocs),
2785    ResultIndex(ResultIndex), GenericLoc(GenericLoc), DefaultLoc(DefaultLoc),
2786    RParenLoc(RParenLoc) {
2787  SubExprs[CONTROLLING] = ControllingExpr;
2788  std::copy(AssocTypes, AssocTypes+NumAssocs, this->AssocTypes);
2789  std::copy(AssocExprs, AssocExprs+NumAssocs, SubExprs+END_EXPR);
2790}
2791
2792GenericSelectionExpr::GenericSelectionExpr(ASTContext &Context,
2793                               SourceLocation GenericLoc, Expr *ControllingExpr,
2794                               TypeSourceInfo **AssocTypes, Expr **AssocExprs,
2795                               unsigned NumAssocs, SourceLocation DefaultLoc,
2796                               SourceLocation RParenLoc,
2797                               bool ContainsUnexpandedParameterPack)
2798  : Expr(GenericSelectionExprClass,
2799         Context.DependentTy,
2800         VK_RValue,
2801         OK_Ordinary,
2802         /*isTypeDependent=*/  true,
2803         /*isValueDependent=*/ true,
2804         ContainsUnexpandedParameterPack),
2805    AssocTypes(new (Context) TypeSourceInfo*[NumAssocs]),
2806    SubExprs(new (Context) Stmt*[END_EXPR+NumAssocs]), NumAssocs(NumAssocs),
2807    ResultIndex(-1U), GenericLoc(GenericLoc), DefaultLoc(DefaultLoc),
2808    RParenLoc(RParenLoc) {
2809  SubExprs[CONTROLLING] = ControllingExpr;
2810  std::copy(AssocTypes, AssocTypes+NumAssocs, this->AssocTypes);
2811  std::copy(AssocExprs, AssocExprs+NumAssocs, SubExprs+END_EXPR);
2812}
2813
2814//===----------------------------------------------------------------------===//
2815//  DesignatedInitExpr
2816//===----------------------------------------------------------------------===//
2817
2818IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() {
2819  assert(Kind == FieldDesignator && "Only valid on a field designator");
2820  if (Field.NameOrField & 0x01)
2821    return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01);
2822  else
2823    return getField()->getIdentifier();
2824}
2825
2826DesignatedInitExpr::DesignatedInitExpr(ASTContext &C, QualType Ty,
2827                                       unsigned NumDesignators,
2828                                       const Designator *Designators,
2829                                       SourceLocation EqualOrColonLoc,
2830                                       bool GNUSyntax,
2831                                       Expr **IndexExprs,
2832                                       unsigned NumIndexExprs,
2833                                       Expr *Init)
2834  : Expr(DesignatedInitExprClass, Ty,
2835         Init->getValueKind(), Init->getObjectKind(),
2836         Init->isTypeDependent(), Init->isValueDependent(),
2837         Init->containsUnexpandedParameterPack()),
2838    EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax),
2839    NumDesignators(NumDesignators), NumSubExprs(NumIndexExprs + 1) {
2840  this->Designators = new (C) Designator[NumDesignators];
2841
2842  // Record the initializer itself.
2843  child_range Child = children();
2844  *Child++ = Init;
2845
2846  // Copy the designators and their subexpressions, computing
2847  // value-dependence along the way.
2848  unsigned IndexIdx = 0;
2849  for (unsigned I = 0; I != NumDesignators; ++I) {
2850    this->Designators[I] = Designators[I];
2851
2852    if (this->Designators[I].isArrayDesignator()) {
2853      // Compute type- and value-dependence.
2854      Expr *Index = IndexExprs[IndexIdx];
2855      if (Index->isTypeDependent() || Index->isValueDependent())
2856        ExprBits.ValueDependent = true;
2857
2858      // Propagate unexpanded parameter packs.
2859      if (Index->containsUnexpandedParameterPack())
2860        ExprBits.ContainsUnexpandedParameterPack = true;
2861
2862      // Copy the index expressions into permanent storage.
2863      *Child++ = IndexExprs[IndexIdx++];
2864    } else if (this->Designators[I].isArrayRangeDesignator()) {
2865      // Compute type- and value-dependence.
2866      Expr *Start = IndexExprs[IndexIdx];
2867      Expr *End = IndexExprs[IndexIdx + 1];
2868      if (Start->isTypeDependent() || Start->isValueDependent() ||
2869          End->isTypeDependent() || End->isValueDependent())
2870        ExprBits.ValueDependent = true;
2871
2872      // Propagate unexpanded parameter packs.
2873      if (Start->containsUnexpandedParameterPack() ||
2874          End->containsUnexpandedParameterPack())
2875        ExprBits.ContainsUnexpandedParameterPack = true;
2876
2877      // Copy the start/end expressions into permanent storage.
2878      *Child++ = IndexExprs[IndexIdx++];
2879      *Child++ = IndexExprs[IndexIdx++];
2880    }
2881  }
2882
2883  assert(IndexIdx == NumIndexExprs && "Wrong number of index expressions");
2884}
2885
2886DesignatedInitExpr *
2887DesignatedInitExpr::Create(ASTContext &C, Designator *Designators,
2888                           unsigned NumDesignators,
2889                           Expr **IndexExprs, unsigned NumIndexExprs,
2890                           SourceLocation ColonOrEqualLoc,
2891                           bool UsesColonSyntax, Expr *Init) {
2892  void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
2893                         sizeof(Stmt *) * (NumIndexExprs + 1), 8);
2894  return new (Mem) DesignatedInitExpr(C, C.VoidTy, NumDesignators, Designators,
2895                                      ColonOrEqualLoc, UsesColonSyntax,
2896                                      IndexExprs, NumIndexExprs, Init);
2897}
2898
2899DesignatedInitExpr *DesignatedInitExpr::CreateEmpty(ASTContext &C,
2900                                                    unsigned NumIndexExprs) {
2901  void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
2902                         sizeof(Stmt *) * (NumIndexExprs + 1), 8);
2903  return new (Mem) DesignatedInitExpr(NumIndexExprs + 1);
2904}
2905
2906void DesignatedInitExpr::setDesignators(ASTContext &C,
2907                                        const Designator *Desigs,
2908                                        unsigned NumDesigs) {
2909  Designators = new (C) Designator[NumDesigs];
2910  NumDesignators = NumDesigs;
2911  for (unsigned I = 0; I != NumDesigs; ++I)
2912    Designators[I] = Desigs[I];
2913}
2914
2915SourceRange DesignatedInitExpr::getDesignatorsSourceRange() const {
2916  DesignatedInitExpr *DIE = const_cast<DesignatedInitExpr*>(this);
2917  if (size() == 1)
2918    return DIE->getDesignator(0)->getSourceRange();
2919  return SourceRange(DIE->getDesignator(0)->getStartLocation(),
2920                     DIE->getDesignator(size()-1)->getEndLocation());
2921}
2922
2923SourceRange DesignatedInitExpr::getSourceRange() const {
2924  SourceLocation StartLoc;
2925  Designator &First =
2926    *const_cast<DesignatedInitExpr*>(this)->designators_begin();
2927  if (First.isFieldDesignator()) {
2928    if (GNUSyntax)
2929      StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc);
2930    else
2931      StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc);
2932  } else
2933    StartLoc =
2934      SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc);
2935  return SourceRange(StartLoc, getInit()->getSourceRange().getEnd());
2936}
2937
2938Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) {
2939  assert(D.Kind == Designator::ArrayDesignator && "Requires array designator");
2940  char* Ptr = static_cast<char*>(static_cast<void *>(this));
2941  Ptr += sizeof(DesignatedInitExpr);
2942  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2943  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
2944}
2945
2946Expr *DesignatedInitExpr::getArrayRangeStart(const Designator& D) {
2947  assert(D.Kind == Designator::ArrayRangeDesignator &&
2948         "Requires array range designator");
2949  char* Ptr = static_cast<char*>(static_cast<void *>(this));
2950  Ptr += sizeof(DesignatedInitExpr);
2951  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2952  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
2953}
2954
2955Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator& D) {
2956  assert(D.Kind == Designator::ArrayRangeDesignator &&
2957         "Requires array range designator");
2958  char* Ptr = static_cast<char*>(static_cast<void *>(this));
2959  Ptr += sizeof(DesignatedInitExpr);
2960  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2961  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2));
2962}
2963
2964/// \brief Replaces the designator at index @p Idx with the series
2965/// of designators in [First, Last).
2966void DesignatedInitExpr::ExpandDesignator(ASTContext &C, unsigned Idx,
2967                                          const Designator *First,
2968                                          const Designator *Last) {
2969  unsigned NumNewDesignators = Last - First;
2970  if (NumNewDesignators == 0) {
2971    std::copy_backward(Designators + Idx + 1,
2972                       Designators + NumDesignators,
2973                       Designators + Idx);
2974    --NumNewDesignators;
2975    return;
2976  } else if (NumNewDesignators == 1) {
2977    Designators[Idx] = *First;
2978    return;
2979  }
2980
2981  Designator *NewDesignators
2982    = new (C) Designator[NumDesignators - 1 + NumNewDesignators];
2983  std::copy(Designators, Designators + Idx, NewDesignators);
2984  std::copy(First, Last, NewDesignators + Idx);
2985  std::copy(Designators + Idx + 1, Designators + NumDesignators,
2986            NewDesignators + Idx + NumNewDesignators);
2987  Designators = NewDesignators;
2988  NumDesignators = NumDesignators - 1 + NumNewDesignators;
2989}
2990
2991ParenListExpr::ParenListExpr(ASTContext& C, SourceLocation lparenloc,
2992                             Expr **exprs, unsigned nexprs,
2993                             SourceLocation rparenloc)
2994  : Expr(ParenListExprClass, QualType(), VK_RValue, OK_Ordinary,
2995         false, false, false),
2996    NumExprs(nexprs), LParenLoc(lparenloc), RParenLoc(rparenloc) {
2997
2998  Exprs = new (C) Stmt*[nexprs];
2999  for (unsigned i = 0; i != nexprs; ++i) {
3000    if (exprs[i]->isTypeDependent())
3001      ExprBits.TypeDependent = true;
3002    if (exprs[i]->isValueDependent())
3003      ExprBits.ValueDependent = true;
3004    if (exprs[i]->containsUnexpandedParameterPack())
3005      ExprBits.ContainsUnexpandedParameterPack = true;
3006
3007    Exprs[i] = exprs[i];
3008  }
3009}
3010
3011const OpaqueValueExpr *OpaqueValueExpr::findInCopyConstruct(const Expr *e) {
3012  if (const ExprWithCleanups *ewc = dyn_cast<ExprWithCleanups>(e))
3013    e = ewc->getSubExpr();
3014  e = cast<CXXConstructExpr>(e)->getArg(0);
3015  while (const ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e))
3016    e = ice->getSubExpr();
3017  return cast<OpaqueValueExpr>(e);
3018}
3019
3020//===----------------------------------------------------------------------===//
3021//  ExprIterator.
3022//===----------------------------------------------------------------------===//
3023
3024Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); }
3025Expr* ExprIterator::operator*() const { return cast<Expr>(*I); }
3026Expr* ExprIterator::operator->() const { return cast<Expr>(*I); }
3027const Expr* ConstExprIterator::operator[](size_t idx) const {
3028  return cast<Expr>(I[idx]);
3029}
3030const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); }
3031const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); }
3032
3033//===----------------------------------------------------------------------===//
3034//  Child Iterators for iterating over subexpressions/substatements
3035//===----------------------------------------------------------------------===//
3036
3037// UnaryExprOrTypeTraitExpr
3038Stmt::child_range UnaryExprOrTypeTraitExpr::children() {
3039  // If this is of a type and the type is a VLA type (and not a typedef), the
3040  // size expression of the VLA needs to be treated as an executable expression.
3041  // Why isn't this weirdness documented better in StmtIterator?
3042  if (isArgumentType()) {
3043    if (const VariableArrayType* T = dyn_cast<VariableArrayType>(
3044                                   getArgumentType().getTypePtr()))
3045      return child_range(child_iterator(T), child_iterator());
3046    return child_range();
3047  }
3048  return child_range(&Argument.Ex, &Argument.Ex + 1);
3049}
3050
3051// ObjCMessageExpr
3052Stmt::child_range ObjCMessageExpr::children() {
3053  Stmt **begin;
3054  if (getReceiverKind() == Instance)
3055    begin = reinterpret_cast<Stmt **>(this + 1);
3056  else
3057    begin = reinterpret_cast<Stmt **>(getArgs());
3058  return child_range(begin,
3059                     reinterpret_cast<Stmt **>(getArgs() + getNumArgs()));
3060}
3061
3062// Blocks
3063BlockDeclRefExpr::BlockDeclRefExpr(VarDecl *d, QualType t, ExprValueKind VK,
3064                                   SourceLocation l, bool ByRef,
3065                                   bool constAdded)
3066  : Expr(BlockDeclRefExprClass, t, VK, OK_Ordinary, false, false,
3067         d->isParameterPack()),
3068    D(d), Loc(l), IsByRef(ByRef), ConstQualAdded(constAdded)
3069{
3070  bool TypeDependent = false;
3071  bool ValueDependent = false;
3072  computeDeclRefDependence(D, getType(), TypeDependent, ValueDependent);
3073  ExprBits.TypeDependent = TypeDependent;
3074  ExprBits.ValueDependent = ValueDependent;
3075}
3076