1//===--- ASTWriterStmt.cpp - Statement and Expression Serialization -------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8///
9/// \file
10/// Implements serialization for Statements and Expressions.
11///
12//===----------------------------------------------------------------------===//
13
14#include "clang/AST/ExprOpenMP.h"
15#include "clang/Serialization/ASTRecordWriter.h"
16#include "clang/Sema/DeclSpec.h"
17#include "clang/AST/ASTContext.h"
18#include "clang/AST/DeclCXX.h"
19#include "clang/AST/DeclObjC.h"
20#include "clang/AST/DeclTemplate.h"
21#include "clang/AST/StmtVisitor.h"
22#include "clang/Lex/Token.h"
23#include "llvm/Bitstream/BitstreamWriter.h"
24using namespace clang;
25
26//===----------------------------------------------------------------------===//
27// Statement/expression serialization
28//===----------------------------------------------------------------------===//
29
30namespace clang {
31
32  class ASTStmtWriter : public StmtVisitor<ASTStmtWriter, void> {
33    ASTWriter &Writer;
34    ASTRecordWriter Record;
35
36    serialization::StmtCode Code;
37    unsigned AbbrevToUse;
38
39  public:
40    ASTStmtWriter(ASTWriter &Writer, ASTWriter::RecordData &Record)
41        : Writer(Writer), Record(Writer, Record),
42          Code(serialization::STMT_NULL_PTR), AbbrevToUse(0) {}
43
44    ASTStmtWriter(const ASTStmtWriter&) = delete;
45
46    uint64_t Emit() {
47      assert(Code != serialization::STMT_NULL_PTR &&
48             "unhandled sub-statement writing AST file");
49      return Record.EmitStmt(Code, AbbrevToUse);
50    }
51
52    void AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo &ArgInfo,
53                                  const TemplateArgumentLoc *Args);
54
55    void VisitStmt(Stmt *S);
56#define STMT(Type, Base) \
57    void Visit##Type(Type *);
58#include "clang/AST/StmtNodes.inc"
59  };
60}
61
62void ASTStmtWriter::AddTemplateKWAndArgsInfo(
63    const ASTTemplateKWAndArgsInfo &ArgInfo, const TemplateArgumentLoc *Args) {
64  Record.AddSourceLocation(ArgInfo.TemplateKWLoc);
65  Record.AddSourceLocation(ArgInfo.LAngleLoc);
66  Record.AddSourceLocation(ArgInfo.RAngleLoc);
67  for (unsigned i = 0; i != ArgInfo.NumTemplateArgs; ++i)
68    Record.AddTemplateArgumentLoc(Args[i]);
69}
70
71void ASTStmtWriter::VisitStmt(Stmt *S) {
72}
73
74void ASTStmtWriter::VisitNullStmt(NullStmt *S) {
75  VisitStmt(S);
76  Record.AddSourceLocation(S->getSemiLoc());
77  Record.push_back(S->NullStmtBits.HasLeadingEmptyMacro);
78  Code = serialization::STMT_NULL;
79}
80
81void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) {
82  VisitStmt(S);
83  Record.push_back(S->size());
84  for (auto *CS : S->body())
85    Record.AddStmt(CS);
86  Record.AddSourceLocation(S->getLBracLoc());
87  Record.AddSourceLocation(S->getRBracLoc());
88  Code = serialization::STMT_COMPOUND;
89}
90
91void ASTStmtWriter::VisitSwitchCase(SwitchCase *S) {
92  VisitStmt(S);
93  Record.push_back(Writer.getSwitchCaseID(S));
94  Record.AddSourceLocation(S->getKeywordLoc());
95  Record.AddSourceLocation(S->getColonLoc());
96}
97
98void ASTStmtWriter::VisitCaseStmt(CaseStmt *S) {
99  VisitSwitchCase(S);
100  Record.push_back(S->caseStmtIsGNURange());
101  Record.AddStmt(S->getLHS());
102  Record.AddStmt(S->getSubStmt());
103  if (S->caseStmtIsGNURange()) {
104    Record.AddStmt(S->getRHS());
105    Record.AddSourceLocation(S->getEllipsisLoc());
106  }
107  Code = serialization::STMT_CASE;
108}
109
110void ASTStmtWriter::VisitDefaultStmt(DefaultStmt *S) {
111  VisitSwitchCase(S);
112  Record.AddStmt(S->getSubStmt());
113  Code = serialization::STMT_DEFAULT;
114}
115
116void ASTStmtWriter::VisitLabelStmt(LabelStmt *S) {
117  VisitStmt(S);
118  Record.push_back(S->isSideEntry());
119  Record.AddDeclRef(S->getDecl());
120  Record.AddStmt(S->getSubStmt());
121  Record.AddSourceLocation(S->getIdentLoc());
122  Code = serialization::STMT_LABEL;
123}
124
125void ASTStmtWriter::VisitAttributedStmt(AttributedStmt *S) {
126  VisitStmt(S);
127  Record.push_back(S->getAttrs().size());
128  Record.AddAttributes(S->getAttrs());
129  Record.AddStmt(S->getSubStmt());
130  Record.AddSourceLocation(S->getAttrLoc());
131  Code = serialization::STMT_ATTRIBUTED;
132}
133
134void ASTStmtWriter::VisitIfStmt(IfStmt *S) {
135  VisitStmt(S);
136
137  bool HasElse = S->getElse() != nullptr;
138  bool HasVar = S->getConditionVariableDeclStmt() != nullptr;
139  bool HasInit = S->getInit() != nullptr;
140
141  Record.push_back(S->isConstexpr());
142  Record.push_back(HasElse);
143  Record.push_back(HasVar);
144  Record.push_back(HasInit);
145
146  Record.AddStmt(S->getCond());
147  Record.AddStmt(S->getThen());
148  if (HasElse)
149    Record.AddStmt(S->getElse());
150  if (HasVar)
151    Record.AddDeclRef(S->getConditionVariable());
152  if (HasInit)
153    Record.AddStmt(S->getInit());
154
155  Record.AddSourceLocation(S->getIfLoc());
156  Record.AddSourceLocation(S->getLParenLoc());
157  Record.AddSourceLocation(S->getRParenLoc());
158  if (HasElse)
159    Record.AddSourceLocation(S->getElseLoc());
160
161  Code = serialization::STMT_IF;
162}
163
164void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) {
165  VisitStmt(S);
166
167  bool HasInit = S->getInit() != nullptr;
168  bool HasVar = S->getConditionVariableDeclStmt() != nullptr;
169  Record.push_back(HasInit);
170  Record.push_back(HasVar);
171  Record.push_back(S->isAllEnumCasesCovered());
172
173  Record.AddStmt(S->getCond());
174  Record.AddStmt(S->getBody());
175  if (HasInit)
176    Record.AddStmt(S->getInit());
177  if (HasVar)
178    Record.AddDeclRef(S->getConditionVariable());
179
180  Record.AddSourceLocation(S->getSwitchLoc());
181  Record.AddSourceLocation(S->getLParenLoc());
182  Record.AddSourceLocation(S->getRParenLoc());
183
184  for (SwitchCase *SC = S->getSwitchCaseList(); SC;
185       SC = SC->getNextSwitchCase())
186    Record.push_back(Writer.RecordSwitchCaseID(SC));
187  Code = serialization::STMT_SWITCH;
188}
189
190void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) {
191  VisitStmt(S);
192
193  bool HasVar = S->getConditionVariableDeclStmt() != nullptr;
194  Record.push_back(HasVar);
195
196  Record.AddStmt(S->getCond());
197  Record.AddStmt(S->getBody());
198  if (HasVar)
199    Record.AddDeclRef(S->getConditionVariable());
200
201  Record.AddSourceLocation(S->getWhileLoc());
202  Record.AddSourceLocation(S->getLParenLoc());
203  Record.AddSourceLocation(S->getRParenLoc());
204  Code = serialization::STMT_WHILE;
205}
206
207void ASTStmtWriter::VisitDoStmt(DoStmt *S) {
208  VisitStmt(S);
209  Record.AddStmt(S->getCond());
210  Record.AddStmt(S->getBody());
211  Record.AddSourceLocation(S->getDoLoc());
212  Record.AddSourceLocation(S->getWhileLoc());
213  Record.AddSourceLocation(S->getRParenLoc());
214  Code = serialization::STMT_DO;
215}
216
217void ASTStmtWriter::VisitForStmt(ForStmt *S) {
218  VisitStmt(S);
219  Record.AddStmt(S->getInit());
220  Record.AddStmt(S->getCond());
221  Record.AddDeclRef(S->getConditionVariable());
222  Record.AddStmt(S->getInc());
223  Record.AddStmt(S->getBody());
224  Record.AddSourceLocation(S->getForLoc());
225  Record.AddSourceLocation(S->getLParenLoc());
226  Record.AddSourceLocation(S->getRParenLoc());
227  Code = serialization::STMT_FOR;
228}
229
230void ASTStmtWriter::VisitGotoStmt(GotoStmt *S) {
231  VisitStmt(S);
232  Record.AddDeclRef(S->getLabel());
233  Record.AddSourceLocation(S->getGotoLoc());
234  Record.AddSourceLocation(S->getLabelLoc());
235  Code = serialization::STMT_GOTO;
236}
237
238void ASTStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
239  VisitStmt(S);
240  Record.AddSourceLocation(S->getGotoLoc());
241  Record.AddSourceLocation(S->getStarLoc());
242  Record.AddStmt(S->getTarget());
243  Code = serialization::STMT_INDIRECT_GOTO;
244}
245
246void ASTStmtWriter::VisitContinueStmt(ContinueStmt *S) {
247  VisitStmt(S);
248  Record.AddSourceLocation(S->getContinueLoc());
249  Code = serialization::STMT_CONTINUE;
250}
251
252void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) {
253  VisitStmt(S);
254  Record.AddSourceLocation(S->getBreakLoc());
255  Code = serialization::STMT_BREAK;
256}
257
258void ASTStmtWriter::VisitReturnStmt(ReturnStmt *S) {
259  VisitStmt(S);
260
261  bool HasNRVOCandidate = S->getNRVOCandidate() != nullptr;
262  Record.push_back(HasNRVOCandidate);
263
264  Record.AddStmt(S->getRetValue());
265  if (HasNRVOCandidate)
266    Record.AddDeclRef(S->getNRVOCandidate());
267
268  Record.AddSourceLocation(S->getReturnLoc());
269  Code = serialization::STMT_RETURN;
270}
271
272void ASTStmtWriter::VisitDeclStmt(DeclStmt *S) {
273  VisitStmt(S);
274  Record.AddSourceLocation(S->getBeginLoc());
275  Record.AddSourceLocation(S->getEndLoc());
276  DeclGroupRef DG = S->getDeclGroup();
277  for (DeclGroupRef::iterator D = DG.begin(), DEnd = DG.end(); D != DEnd; ++D)
278    Record.AddDeclRef(*D);
279  Code = serialization::STMT_DECL;
280}
281
282void ASTStmtWriter::VisitAsmStmt(AsmStmt *S) {
283  VisitStmt(S);
284  Record.push_back(S->getNumOutputs());
285  Record.push_back(S->getNumInputs());
286  Record.push_back(S->getNumClobbers());
287  Record.AddSourceLocation(S->getAsmLoc());
288  Record.push_back(S->isVolatile());
289  Record.push_back(S->isSimple());
290}
291
292void ASTStmtWriter::VisitGCCAsmStmt(GCCAsmStmt *S) {
293  VisitAsmStmt(S);
294  Record.push_back(S->getNumLabels());
295  Record.AddSourceLocation(S->getRParenLoc());
296  Record.AddStmt(S->getAsmString());
297
298  // Outputs
299  for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
300    Record.AddIdentifierRef(S->getOutputIdentifier(I));
301    Record.AddStmt(S->getOutputConstraintLiteral(I));
302    Record.AddStmt(S->getOutputExpr(I));
303  }
304
305  // Inputs
306  for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
307    Record.AddIdentifierRef(S->getInputIdentifier(I));
308    Record.AddStmt(S->getInputConstraintLiteral(I));
309    Record.AddStmt(S->getInputExpr(I));
310  }
311
312  // Clobbers
313  for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)
314    Record.AddStmt(S->getClobberStringLiteral(I));
315
316  // Labels
317  for (auto *E : S->labels()) Record.AddStmt(E);
318
319  Code = serialization::STMT_GCCASM;
320}
321
322void ASTStmtWriter::VisitMSAsmStmt(MSAsmStmt *S) {
323  VisitAsmStmt(S);
324  Record.AddSourceLocation(S->getLBraceLoc());
325  Record.AddSourceLocation(S->getEndLoc());
326  Record.push_back(S->getNumAsmToks());
327  Record.AddString(S->getAsmString());
328
329  // Tokens
330  for (unsigned I = 0, N = S->getNumAsmToks(); I != N; ++I) {
331    // FIXME: Move this to ASTRecordWriter?
332    Writer.AddToken(S->getAsmToks()[I], Record.getRecordData());
333  }
334
335  // Clobbers
336  for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I) {
337    Record.AddString(S->getClobber(I));
338  }
339
340  // Outputs
341  for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
342    Record.AddStmt(S->getOutputExpr(I));
343    Record.AddString(S->getOutputConstraint(I));
344  }
345
346  // Inputs
347  for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
348    Record.AddStmt(S->getInputExpr(I));
349    Record.AddString(S->getInputConstraint(I));
350  }
351
352  Code = serialization::STMT_MSASM;
353}
354
355void ASTStmtWriter::VisitCoroutineBodyStmt(CoroutineBodyStmt *CoroStmt) {
356  VisitStmt(CoroStmt);
357  Record.push_back(CoroStmt->getParamMoves().size());
358  for (Stmt *S : CoroStmt->children())
359    Record.AddStmt(S);
360  Code = serialization::STMT_COROUTINE_BODY;
361}
362
363void ASTStmtWriter::VisitCoreturnStmt(CoreturnStmt *S) {
364  VisitStmt(S);
365  Record.AddSourceLocation(S->getKeywordLoc());
366  Record.AddStmt(S->getOperand());
367  Record.AddStmt(S->getPromiseCall());
368  Record.push_back(S->isImplicit());
369  Code = serialization::STMT_CORETURN;
370}
371
372void ASTStmtWriter::VisitCoroutineSuspendExpr(CoroutineSuspendExpr *E) {
373  VisitExpr(E);
374  Record.AddSourceLocation(E->getKeywordLoc());
375  for (Stmt *S : E->children())
376    Record.AddStmt(S);
377  Record.AddStmt(E->getOpaqueValue());
378}
379
380void ASTStmtWriter::VisitCoawaitExpr(CoawaitExpr *E) {
381  VisitCoroutineSuspendExpr(E);
382  Record.push_back(E->isImplicit());
383  Code = serialization::EXPR_COAWAIT;
384}
385
386void ASTStmtWriter::VisitCoyieldExpr(CoyieldExpr *E) {
387  VisitCoroutineSuspendExpr(E);
388  Code = serialization::EXPR_COYIELD;
389}
390
391void ASTStmtWriter::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) {
392  VisitExpr(E);
393  Record.AddSourceLocation(E->getKeywordLoc());
394  for (Stmt *S : E->children())
395    Record.AddStmt(S);
396  Code = serialization::EXPR_DEPENDENT_COAWAIT;
397}
398
399static void
400addConstraintSatisfaction(ASTRecordWriter &Record,
401                          const ASTConstraintSatisfaction &Satisfaction) {
402  Record.push_back(Satisfaction.IsSatisfied);
403  if (!Satisfaction.IsSatisfied) {
404    Record.push_back(Satisfaction.NumRecords);
405    for (const auto &DetailRecord : Satisfaction) {
406      Record.AddStmt(const_cast<Expr *>(DetailRecord.first));
407      auto *E = DetailRecord.second.dyn_cast<Expr *>();
408      Record.push_back(E == nullptr);
409      if (E)
410        Record.AddStmt(E);
411      else {
412        auto *Diag = DetailRecord.second.get<std::pair<SourceLocation,
413                                                       StringRef> *>();
414        Record.AddSourceLocation(Diag->first);
415        Record.AddString(Diag->second);
416      }
417    }
418  }
419}
420
421static void
422addSubstitutionDiagnostic(
423    ASTRecordWriter &Record,
424    const concepts::Requirement::SubstitutionDiagnostic *D) {
425  Record.AddString(D->SubstitutedEntity);
426  Record.AddSourceLocation(D->DiagLoc);
427  Record.AddString(D->DiagMessage);
428}
429
430void ASTStmtWriter::VisitConceptSpecializationExpr(
431        ConceptSpecializationExpr *E) {
432  VisitExpr(E);
433  ArrayRef<TemplateArgument> TemplateArgs = E->getTemplateArguments();
434  Record.push_back(TemplateArgs.size());
435  Record.AddNestedNameSpecifierLoc(E->getNestedNameSpecifierLoc());
436  Record.AddSourceLocation(E->getTemplateKWLoc());
437  Record.AddDeclarationNameInfo(E->getConceptNameInfo());
438  Record.AddDeclRef(E->getNamedConcept());
439  Record.AddDeclRef(E->getFoundDecl());
440  Record.AddASTTemplateArgumentListInfo(E->getTemplateArgsAsWritten());
441  for (const TemplateArgument &Arg : TemplateArgs)
442    Record.AddTemplateArgument(Arg);
443  if (!E->isValueDependent())
444    addConstraintSatisfaction(Record, E->getSatisfaction());
445
446  Code = serialization::EXPR_CONCEPT_SPECIALIZATION;
447}
448
449void ASTStmtWriter::VisitRequiresExpr(RequiresExpr *E) {
450  VisitExpr(E);
451  Record.push_back(E->getLocalParameters().size());
452  Record.push_back(E->getRequirements().size());
453  Record.AddSourceLocation(E->RequiresExprBits.RequiresKWLoc);
454  Record.push_back(E->RequiresExprBits.IsSatisfied);
455  Record.AddDeclRef(E->getBody());
456  for (ParmVarDecl *P : E->getLocalParameters())
457    Record.AddDeclRef(P);
458  for (concepts::Requirement *R : E->getRequirements()) {
459    if (auto *TypeReq = dyn_cast<concepts::TypeRequirement>(R)) {
460      Record.push_back(concepts::Requirement::RK_Type);
461      Record.push_back(TypeReq->Status);
462      if (TypeReq->Status == concepts::TypeRequirement::SS_SubstitutionFailure)
463        addSubstitutionDiagnostic(Record, TypeReq->getSubstitutionDiagnostic());
464      else
465        Record.AddTypeSourceInfo(TypeReq->getType());
466    } else if (auto *ExprReq = dyn_cast<concepts::ExprRequirement>(R)) {
467      Record.push_back(ExprReq->getKind());
468      Record.push_back(ExprReq->Status);
469      if (ExprReq->isExprSubstitutionFailure()) {
470        addSubstitutionDiagnostic(Record,
471         ExprReq->Value.get<concepts::Requirement::SubstitutionDiagnostic *>());
472      } else
473        Record.AddStmt(ExprReq->Value.get<Expr *>());
474      if (ExprReq->getKind() == concepts::Requirement::RK_Compound) {
475        Record.AddSourceLocation(ExprReq->NoexceptLoc);
476        const auto &RetReq = ExprReq->getReturnTypeRequirement();
477        if (RetReq.isSubstitutionFailure()) {
478          Record.push_back(2);
479          addSubstitutionDiagnostic(Record, RetReq.getSubstitutionDiagnostic());
480        } else if (RetReq.isTypeConstraint()) {
481          Record.push_back(1);
482          Record.AddTemplateParameterList(
483              RetReq.getTypeConstraintTemplateParameterList());
484          if (ExprReq->Status >=
485              concepts::ExprRequirement::SS_ConstraintsNotSatisfied)
486            Record.AddStmt(
487                ExprReq->getReturnTypeRequirementSubstitutedConstraintExpr());
488        } else {
489          assert(RetReq.isEmpty());
490          Record.push_back(0);
491        }
492      }
493    } else {
494      auto *NestedReq = cast<concepts::NestedRequirement>(R);
495      Record.push_back(concepts::Requirement::RK_Nested);
496      Record.push_back(NestedReq->isSubstitutionFailure());
497      if (NestedReq->isSubstitutionFailure()){
498        addSubstitutionDiagnostic(Record,
499                                  NestedReq->getSubstitutionDiagnostic());
500      } else {
501        Record.AddStmt(NestedReq->Value.get<Expr *>());
502        if (!NestedReq->isDependent())
503          addConstraintSatisfaction(Record, *NestedReq->Satisfaction);
504      }
505    }
506  }
507  Record.AddSourceLocation(E->getEndLoc());
508
509  Code = serialization::EXPR_REQUIRES;
510}
511
512
513void ASTStmtWriter::VisitCapturedStmt(CapturedStmt *S) {
514  VisitStmt(S);
515  // NumCaptures
516  Record.push_back(std::distance(S->capture_begin(), S->capture_end()));
517
518  // CapturedDecl and captured region kind
519  Record.AddDeclRef(S->getCapturedDecl());
520  Record.push_back(S->getCapturedRegionKind());
521
522  Record.AddDeclRef(S->getCapturedRecordDecl());
523
524  // Capture inits
525  for (auto *I : S->capture_inits())
526    Record.AddStmt(I);
527
528  // Body
529  Record.AddStmt(S->getCapturedStmt());
530
531  // Captures
532  for (const auto &I : S->captures()) {
533    if (I.capturesThis() || I.capturesVariableArrayType())
534      Record.AddDeclRef(nullptr);
535    else
536      Record.AddDeclRef(I.getCapturedVar());
537    Record.push_back(I.getCaptureKind());
538    Record.AddSourceLocation(I.getLocation());
539  }
540
541  Code = serialization::STMT_CAPTURED;
542}
543
544void ASTStmtWriter::VisitExpr(Expr *E) {
545  VisitStmt(E);
546  Record.AddTypeRef(E->getType());
547  Record.push_back(E->isTypeDependent());
548  Record.push_back(E->isValueDependent());
549  Record.push_back(E->isInstantiationDependent());
550  Record.push_back(E->containsUnexpandedParameterPack());
551  Record.push_back(E->containsErrors());
552  Record.push_back(E->getValueKind());
553  Record.push_back(E->getObjectKind());
554}
555
556void ASTStmtWriter::VisitConstantExpr(ConstantExpr *E) {
557  VisitExpr(E);
558  Record.push_back(E->ConstantExprBits.ResultKind);
559
560  Record.push_back(E->ConstantExprBits.APValueKind);
561  Record.push_back(E->ConstantExprBits.IsUnsigned);
562  Record.push_back(E->ConstantExprBits.BitWidth);
563  // HasCleanup not serialized since we can just query the APValue.
564  Record.push_back(E->ConstantExprBits.IsImmediateInvocation);
565
566  switch (E->ConstantExprBits.ResultKind) {
567  case ConstantExpr::RSK_None:
568    break;
569  case ConstantExpr::RSK_Int64:
570    Record.push_back(E->Int64Result());
571    break;
572  case ConstantExpr::RSK_APValue:
573    Record.AddAPValue(E->APValueResult());
574    break;
575  default:
576    llvm_unreachable("unexpected ResultKind!");
577  }
578
579  Record.AddStmt(E->getSubExpr());
580  Code = serialization::EXPR_CONSTANT;
581}
582
583void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) {
584  VisitExpr(E);
585
586  bool HasFunctionName = E->getFunctionName() != nullptr;
587  Record.push_back(HasFunctionName);
588  Record.push_back(E->getIdentKind()); // FIXME: stable encoding
589  Record.AddSourceLocation(E->getLocation());
590  if (HasFunctionName)
591    Record.AddStmt(E->getFunctionName());
592  Code = serialization::EXPR_PREDEFINED;
593}
594
595void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) {
596  VisitExpr(E);
597
598  Record.push_back(E->hasQualifier());
599  Record.push_back(E->getDecl() != E->getFoundDecl());
600  Record.push_back(E->hasTemplateKWAndArgsInfo());
601  Record.push_back(E->hadMultipleCandidates());
602  Record.push_back(E->refersToEnclosingVariableOrCapture());
603  Record.push_back(E->isNonOdrUse());
604
605  if (E->hasTemplateKWAndArgsInfo()) {
606    unsigned NumTemplateArgs = E->getNumTemplateArgs();
607    Record.push_back(NumTemplateArgs);
608  }
609
610  DeclarationName::NameKind nk = (E->getDecl()->getDeclName().getNameKind());
611
612  if ((!E->hasTemplateKWAndArgsInfo()) && (!E->hasQualifier()) &&
613      (E->getDecl() == E->getFoundDecl()) &&
614      nk == DeclarationName::Identifier &&
615      !E->refersToEnclosingVariableOrCapture() && !E->isNonOdrUse()) {
616    AbbrevToUse = Writer.getDeclRefExprAbbrev();
617  }
618
619  if (E->hasQualifier())
620    Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
621
622  if (E->getDecl() != E->getFoundDecl())
623    Record.AddDeclRef(E->getFoundDecl());
624
625  if (E->hasTemplateKWAndArgsInfo())
626    AddTemplateKWAndArgsInfo(*E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
627                             E->getTrailingObjects<TemplateArgumentLoc>());
628
629  Record.AddDeclRef(E->getDecl());
630  Record.AddSourceLocation(E->getLocation());
631  Record.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName());
632  Code = serialization::EXPR_DECL_REF;
633}
634
635void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) {
636  VisitExpr(E);
637  Record.AddSourceLocation(E->getLocation());
638  Record.AddAPInt(E->getValue());
639
640  if (E->getValue().getBitWidth() == 32) {
641    AbbrevToUse = Writer.getIntegerLiteralAbbrev();
642  }
643
644  Code = serialization::EXPR_INTEGER_LITERAL;
645}
646
647void ASTStmtWriter::VisitFixedPointLiteral(FixedPointLiteral *E) {
648  VisitExpr(E);
649  Record.AddSourceLocation(E->getLocation());
650  Record.push_back(E->getScale());
651  Record.AddAPInt(E->getValue());
652  Code = serialization::EXPR_FIXEDPOINT_LITERAL;
653}
654
655void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) {
656  VisitExpr(E);
657  Record.push_back(E->getRawSemantics());
658  Record.push_back(E->isExact());
659  Record.AddAPFloat(E->getValue());
660  Record.AddSourceLocation(E->getLocation());
661  Code = serialization::EXPR_FLOATING_LITERAL;
662}
663
664void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
665  VisitExpr(E);
666  Record.AddStmt(E->getSubExpr());
667  Code = serialization::EXPR_IMAGINARY_LITERAL;
668}
669
670void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) {
671  VisitExpr(E);
672
673  // Store the various bits of data of StringLiteral.
674  Record.push_back(E->getNumConcatenated());
675  Record.push_back(E->getLength());
676  Record.push_back(E->getCharByteWidth());
677  Record.push_back(E->getKind());
678  Record.push_back(E->isPascal());
679
680  // Store the trailing array of SourceLocation.
681  for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
682    Record.AddSourceLocation(E->getStrTokenLoc(I));
683
684  // Store the trailing array of char holding the string data.
685  StringRef StrData = E->getBytes();
686  for (unsigned I = 0, N = E->getByteLength(); I != N; ++I)
687    Record.push_back(StrData[I]);
688
689  Code = serialization::EXPR_STRING_LITERAL;
690}
691
692void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) {
693  VisitExpr(E);
694  Record.push_back(E->getValue());
695  Record.AddSourceLocation(E->getLocation());
696  Record.push_back(E->getKind());
697
698  AbbrevToUse = Writer.getCharacterLiteralAbbrev();
699
700  Code = serialization::EXPR_CHARACTER_LITERAL;
701}
702
703void ASTStmtWriter::VisitParenExpr(ParenExpr *E) {
704  VisitExpr(E);
705  Record.AddSourceLocation(E->getLParen());
706  Record.AddSourceLocation(E->getRParen());
707  Record.AddStmt(E->getSubExpr());
708  Code = serialization::EXPR_PAREN;
709}
710
711void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) {
712  VisitExpr(E);
713  Record.push_back(E->getNumExprs());
714  for (auto *SubStmt : E->exprs())
715    Record.AddStmt(SubStmt);
716  Record.AddSourceLocation(E->getLParenLoc());
717  Record.AddSourceLocation(E->getRParenLoc());
718  Code = serialization::EXPR_PAREN_LIST;
719}
720
721void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) {
722  VisitExpr(E);
723  bool HasFPFeatures = E->hasStoredFPFeatures();
724  // Write this first for easy access when deserializing, as they affect the
725  // size of the UnaryOperator.
726  Record.push_back(HasFPFeatures);
727  Record.AddStmt(E->getSubExpr());
728  Record.push_back(E->getOpcode()); // FIXME: stable encoding
729  Record.AddSourceLocation(E->getOperatorLoc());
730  Record.push_back(E->canOverflow());
731  if (HasFPFeatures)
732    Record.push_back(E->getStoredFPFeatures().getAsOpaqueInt());
733  Code = serialization::EXPR_UNARY_OPERATOR;
734}
735
736void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) {
737  VisitExpr(E);
738  Record.push_back(E->getNumComponents());
739  Record.push_back(E->getNumExpressions());
740  Record.AddSourceLocation(E->getOperatorLoc());
741  Record.AddSourceLocation(E->getRParenLoc());
742  Record.AddTypeSourceInfo(E->getTypeSourceInfo());
743  for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
744    const OffsetOfNode &ON = E->getComponent(I);
745    Record.push_back(ON.getKind()); // FIXME: Stable encoding
746    Record.AddSourceLocation(ON.getSourceRange().getBegin());
747    Record.AddSourceLocation(ON.getSourceRange().getEnd());
748    switch (ON.getKind()) {
749    case OffsetOfNode::Array:
750      Record.push_back(ON.getArrayExprIndex());
751      break;
752
753    case OffsetOfNode::Field:
754      Record.AddDeclRef(ON.getField());
755      break;
756
757    case OffsetOfNode::Identifier:
758      Record.AddIdentifierRef(ON.getFieldName());
759      break;
760
761    case OffsetOfNode::Base:
762      Record.AddCXXBaseSpecifier(*ON.getBase());
763      break;
764    }
765  }
766  for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
767    Record.AddStmt(E->getIndexExpr(I));
768  Code = serialization::EXPR_OFFSETOF;
769}
770
771void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
772  VisitExpr(E);
773  Record.push_back(E->getKind());
774  if (E->isArgumentType())
775    Record.AddTypeSourceInfo(E->getArgumentTypeInfo());
776  else {
777    Record.push_back(0);
778    Record.AddStmt(E->getArgumentExpr());
779  }
780  Record.AddSourceLocation(E->getOperatorLoc());
781  Record.AddSourceLocation(E->getRParenLoc());
782  Code = serialization::EXPR_SIZEOF_ALIGN_OF;
783}
784
785void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
786  VisitExpr(E);
787  Record.AddStmt(E->getLHS());
788  Record.AddStmt(E->getRHS());
789  Record.AddSourceLocation(E->getRBracketLoc());
790  Code = serialization::EXPR_ARRAY_SUBSCRIPT;
791}
792
793void ASTStmtWriter::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E) {
794  VisitExpr(E);
795  Record.AddStmt(E->getBase());
796  Record.AddStmt(E->getRowIdx());
797  Record.AddStmt(E->getColumnIdx());
798  Record.AddSourceLocation(E->getRBracketLoc());
799  Code = serialization::EXPR_ARRAY_SUBSCRIPT;
800}
801
802void ASTStmtWriter::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {
803  VisitExpr(E);
804  Record.AddStmt(E->getBase());
805  Record.AddStmt(E->getLowerBound());
806  Record.AddStmt(E->getLength());
807  Record.AddStmt(E->getStride());
808  Record.AddSourceLocation(E->getColonLocFirst());
809  Record.AddSourceLocation(E->getColonLocSecond());
810  Record.AddSourceLocation(E->getRBracketLoc());
811  Code = serialization::EXPR_OMP_ARRAY_SECTION;
812}
813
814void ASTStmtWriter::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
815  VisitExpr(E);
816  Record.push_back(E->getDimensions().size());
817  Record.AddStmt(E->getBase());
818  for (Expr *Dim : E->getDimensions())
819    Record.AddStmt(Dim);
820  for (SourceRange SR : E->getBracketsRanges())
821    Record.AddSourceRange(SR);
822  Record.AddSourceLocation(E->getLParenLoc());
823  Record.AddSourceLocation(E->getRParenLoc());
824  Code = serialization::EXPR_OMP_ARRAY_SHAPING;
825}
826
827void ASTStmtWriter::VisitOMPIteratorExpr(OMPIteratorExpr *E) {
828  VisitExpr(E);
829  Record.push_back(E->numOfIterators());
830  Record.AddSourceLocation(E->getIteratorKwLoc());
831  Record.AddSourceLocation(E->getLParenLoc());
832  Record.AddSourceLocation(E->getRParenLoc());
833  for (unsigned I = 0, End = E->numOfIterators(); I < End; ++I) {
834    Record.AddDeclRef(E->getIteratorDecl(I));
835    Record.AddSourceLocation(E->getAssignLoc(I));
836    OMPIteratorExpr::IteratorRange Range = E->getIteratorRange(I);
837    Record.AddStmt(Range.Begin);
838    Record.AddStmt(Range.End);
839    Record.AddStmt(Range.Step);
840    Record.AddSourceLocation(E->getColonLoc(I));
841    if (Range.Step)
842      Record.AddSourceLocation(E->getSecondColonLoc(I));
843    // Serialize helpers
844    OMPIteratorHelperData &HD = E->getHelper(I);
845    Record.AddDeclRef(HD.CounterVD);
846    Record.AddStmt(HD.Upper);
847    Record.AddStmt(HD.Update);
848    Record.AddStmt(HD.CounterUpdate);
849  }
850  Code = serialization::EXPR_OMP_ITERATOR;
851}
852
853void ASTStmtWriter::VisitCallExpr(CallExpr *E) {
854  VisitExpr(E);
855  Record.push_back(E->getNumArgs());
856  Record.push_back(E->hasStoredFPFeatures());
857  Record.AddSourceLocation(E->getRParenLoc());
858  Record.AddStmt(E->getCallee());
859  for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
860       Arg != ArgEnd; ++Arg)
861    Record.AddStmt(*Arg);
862  Record.push_back(static_cast<unsigned>(E->getADLCallKind()));
863  if (E->hasStoredFPFeatures())
864    Record.push_back(E->getFPFeatures().getAsOpaqueInt());
865  Code = serialization::EXPR_CALL;
866}
867
868void ASTStmtWriter::VisitRecoveryExpr(RecoveryExpr *E) {
869  VisitExpr(E);
870  Record.push_back(std::distance(E->children().begin(), E->children().end()));
871  Record.AddSourceLocation(E->getBeginLoc());
872  Record.AddSourceLocation(E->getEndLoc());
873  for (Stmt *Child : E->children())
874    Record.AddStmt(Child);
875  Code = serialization::EXPR_RECOVERY;
876}
877
878void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) {
879  VisitExpr(E);
880
881  bool HasQualifier = E->hasQualifier();
882  bool HasFoundDecl =
883      E->hasQualifierOrFoundDecl() &&
884      (E->getFoundDecl().getDecl() != E->getMemberDecl() ||
885       E->getFoundDecl().getAccess() != E->getMemberDecl()->getAccess());
886  bool HasTemplateInfo = E->hasTemplateKWAndArgsInfo();
887  unsigned NumTemplateArgs = E->getNumTemplateArgs();
888
889  // Write these first for easy access when deserializing, as they affect the
890  // size of the MemberExpr.
891  Record.push_back(HasQualifier);
892  Record.push_back(HasFoundDecl);
893  Record.push_back(HasTemplateInfo);
894  Record.push_back(NumTemplateArgs);
895
896  Record.AddStmt(E->getBase());
897  Record.AddDeclRef(E->getMemberDecl());
898  Record.AddDeclarationNameLoc(E->MemberDNLoc,
899                               E->getMemberDecl()->getDeclName());
900  Record.AddSourceLocation(E->getMemberLoc());
901  Record.push_back(E->isArrow());
902  Record.push_back(E->hadMultipleCandidates());
903  Record.push_back(E->isNonOdrUse());
904  Record.AddSourceLocation(E->getOperatorLoc());
905
906  if (HasFoundDecl) {
907    DeclAccessPair FoundDecl = E->getFoundDecl();
908    Record.AddDeclRef(FoundDecl.getDecl());
909    Record.push_back(FoundDecl.getAccess());
910  }
911
912  if (HasQualifier)
913    Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
914
915  if (HasTemplateInfo)
916    AddTemplateKWAndArgsInfo(*E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
917                             E->getTrailingObjects<TemplateArgumentLoc>());
918
919  Code = serialization::EXPR_MEMBER;
920}
921
922void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) {
923  VisitExpr(E);
924  Record.AddStmt(E->getBase());
925  Record.AddSourceLocation(E->getIsaMemberLoc());
926  Record.AddSourceLocation(E->getOpLoc());
927  Record.push_back(E->isArrow());
928  Code = serialization::EXPR_OBJC_ISA;
929}
930
931void ASTStmtWriter::
932VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
933  VisitExpr(E);
934  Record.AddStmt(E->getSubExpr());
935  Record.push_back(E->shouldCopy());
936  Code = serialization::EXPR_OBJC_INDIRECT_COPY_RESTORE;
937}
938
939void ASTStmtWriter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
940  VisitExplicitCastExpr(E);
941  Record.AddSourceLocation(E->getLParenLoc());
942  Record.AddSourceLocation(E->getBridgeKeywordLoc());
943  Record.push_back(E->getBridgeKind()); // FIXME: Stable encoding
944  Code = serialization::EXPR_OBJC_BRIDGED_CAST;
945}
946
947void ASTStmtWriter::VisitCastExpr(CastExpr *E) {
948  VisitExpr(E);
949  Record.push_back(E->path_size());
950  Record.push_back(E->hasStoredFPFeatures());
951  Record.AddStmt(E->getSubExpr());
952  Record.push_back(E->getCastKind()); // FIXME: stable encoding
953
954  for (CastExpr::path_iterator
955         PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI)
956    Record.AddCXXBaseSpecifier(**PI);
957
958  if (E->hasStoredFPFeatures())
959    Record.push_back(E->getFPFeatures().getAsOpaqueInt());
960}
961
962void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) {
963  VisitExpr(E);
964  bool HasFPFeatures = E->hasStoredFPFeatures();
965  // Write this first for easy access when deserializing, as they affect the
966  // size of the UnaryOperator.
967  Record.push_back(HasFPFeatures);
968  Record.push_back(E->getOpcode()); // FIXME: stable encoding
969  Record.AddStmt(E->getLHS());
970  Record.AddStmt(E->getRHS());
971  Record.AddSourceLocation(E->getOperatorLoc());
972  if (HasFPFeatures)
973    Record.push_back(E->getStoredFPFeatures().getAsOpaqueInt());
974  Code = serialization::EXPR_BINARY_OPERATOR;
975}
976
977void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
978  VisitBinaryOperator(E);
979  Record.AddTypeRef(E->getComputationLHSType());
980  Record.AddTypeRef(E->getComputationResultType());
981  Code = serialization::EXPR_COMPOUND_ASSIGN_OPERATOR;
982}
983
984void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) {
985  VisitExpr(E);
986  Record.AddStmt(E->getCond());
987  Record.AddStmt(E->getLHS());
988  Record.AddStmt(E->getRHS());
989  Record.AddSourceLocation(E->getQuestionLoc());
990  Record.AddSourceLocation(E->getColonLoc());
991  Code = serialization::EXPR_CONDITIONAL_OPERATOR;
992}
993
994void
995ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
996  VisitExpr(E);
997  Record.AddStmt(E->getOpaqueValue());
998  Record.AddStmt(E->getCommon());
999  Record.AddStmt(E->getCond());
1000  Record.AddStmt(E->getTrueExpr());
1001  Record.AddStmt(E->getFalseExpr());
1002  Record.AddSourceLocation(E->getQuestionLoc());
1003  Record.AddSourceLocation(E->getColonLoc());
1004  Code = serialization::EXPR_BINARY_CONDITIONAL_OPERATOR;
1005}
1006
1007void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
1008  VisitCastExpr(E);
1009  Record.push_back(E->isPartOfExplicitCast());
1010
1011  if (E->path_size() == 0 && !E->hasStoredFPFeatures())
1012    AbbrevToUse = Writer.getExprImplicitCastAbbrev();
1013
1014  Code = serialization::EXPR_IMPLICIT_CAST;
1015}
1016
1017void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
1018  VisitCastExpr(E);
1019  Record.AddTypeSourceInfo(E->getTypeInfoAsWritten());
1020}
1021
1022void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) {
1023  VisitExplicitCastExpr(E);
1024  Record.AddSourceLocation(E->getLParenLoc());
1025  Record.AddSourceLocation(E->getRParenLoc());
1026  Code = serialization::EXPR_CSTYLE_CAST;
1027}
1028
1029void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
1030  VisitExpr(E);
1031  Record.AddSourceLocation(E->getLParenLoc());
1032  Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1033  Record.AddStmt(E->getInitializer());
1034  Record.push_back(E->isFileScope());
1035  Code = serialization::EXPR_COMPOUND_LITERAL;
1036}
1037
1038void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
1039  VisitExpr(E);
1040  Record.AddStmt(E->getBase());
1041  Record.AddIdentifierRef(&E->getAccessor());
1042  Record.AddSourceLocation(E->getAccessorLoc());
1043  Code = serialization::EXPR_EXT_VECTOR_ELEMENT;
1044}
1045
1046void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) {
1047  VisitExpr(E);
1048  // NOTE: only add the (possibly null) syntactic form.
1049  // No need to serialize the isSemanticForm flag and the semantic form.
1050  Record.AddStmt(E->getSyntacticForm());
1051  Record.AddSourceLocation(E->getLBraceLoc());
1052  Record.AddSourceLocation(E->getRBraceLoc());
1053  bool isArrayFiller = E->ArrayFillerOrUnionFieldInit.is<Expr*>();
1054  Record.push_back(isArrayFiller);
1055  if (isArrayFiller)
1056    Record.AddStmt(E->getArrayFiller());
1057  else
1058    Record.AddDeclRef(E->getInitializedFieldInUnion());
1059  Record.push_back(E->hadArrayRangeDesignator());
1060  Record.push_back(E->getNumInits());
1061  if (isArrayFiller) {
1062    // ArrayFiller may have filled "holes" due to designated initializer.
1063    // Replace them by 0 to indicate that the filler goes in that place.
1064    Expr *filler = E->getArrayFiller();
1065    for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
1066      Record.AddStmt(E->getInit(I) != filler ? E->getInit(I) : nullptr);
1067  } else {
1068    for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
1069      Record.AddStmt(E->getInit(I));
1070  }
1071  Code = serialization::EXPR_INIT_LIST;
1072}
1073
1074void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
1075  VisitExpr(E);
1076  Record.push_back(E->getNumSubExprs());
1077  for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
1078    Record.AddStmt(E->getSubExpr(I));
1079  Record.AddSourceLocation(E->getEqualOrColonLoc());
1080  Record.push_back(E->usesGNUSyntax());
1081  for (const DesignatedInitExpr::Designator &D : E->designators()) {
1082    if (D.isFieldDesignator()) {
1083      if (FieldDecl *Field = D.getField()) {
1084        Record.push_back(serialization::DESIG_FIELD_DECL);
1085        Record.AddDeclRef(Field);
1086      } else {
1087        Record.push_back(serialization::DESIG_FIELD_NAME);
1088        Record.AddIdentifierRef(D.getFieldName());
1089      }
1090      Record.AddSourceLocation(D.getDotLoc());
1091      Record.AddSourceLocation(D.getFieldLoc());
1092    } else if (D.isArrayDesignator()) {
1093      Record.push_back(serialization::DESIG_ARRAY);
1094      Record.push_back(D.getFirstExprIndex());
1095      Record.AddSourceLocation(D.getLBracketLoc());
1096      Record.AddSourceLocation(D.getRBracketLoc());
1097    } else {
1098      assert(D.isArrayRangeDesignator() && "Unknown designator");
1099      Record.push_back(serialization::DESIG_ARRAY_RANGE);
1100      Record.push_back(D.getFirstExprIndex());
1101      Record.AddSourceLocation(D.getLBracketLoc());
1102      Record.AddSourceLocation(D.getEllipsisLoc());
1103      Record.AddSourceLocation(D.getRBracketLoc());
1104    }
1105  }
1106  Code = serialization::EXPR_DESIGNATED_INIT;
1107}
1108
1109void ASTStmtWriter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
1110  VisitExpr(E);
1111  Record.AddStmt(E->getBase());
1112  Record.AddStmt(E->getUpdater());
1113  Code = serialization::EXPR_DESIGNATED_INIT_UPDATE;
1114}
1115
1116void ASTStmtWriter::VisitNoInitExpr(NoInitExpr *E) {
1117  VisitExpr(E);
1118  Code = serialization::EXPR_NO_INIT;
1119}
1120
1121void ASTStmtWriter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
1122  VisitExpr(E);
1123  Record.AddStmt(E->SubExprs[0]);
1124  Record.AddStmt(E->SubExprs[1]);
1125  Code = serialization::EXPR_ARRAY_INIT_LOOP;
1126}
1127
1128void ASTStmtWriter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
1129  VisitExpr(E);
1130  Code = serialization::EXPR_ARRAY_INIT_INDEX;
1131}
1132
1133void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
1134  VisitExpr(E);
1135  Code = serialization::EXPR_IMPLICIT_VALUE_INIT;
1136}
1137
1138void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
1139  VisitExpr(E);
1140  Record.AddStmt(E->getSubExpr());
1141  Record.AddTypeSourceInfo(E->getWrittenTypeInfo());
1142  Record.AddSourceLocation(E->getBuiltinLoc());
1143  Record.AddSourceLocation(E->getRParenLoc());
1144  Record.push_back(E->isMicrosoftABI());
1145  Code = serialization::EXPR_VA_ARG;
1146}
1147
1148void ASTStmtWriter::VisitSourceLocExpr(SourceLocExpr *E) {
1149  VisitExpr(E);
1150  Record.AddDeclRef(cast_or_null<Decl>(E->getParentContext()));
1151  Record.AddSourceLocation(E->getBeginLoc());
1152  Record.AddSourceLocation(E->getEndLoc());
1153  Record.push_back(E->getIdentKind());
1154  Code = serialization::EXPR_SOURCE_LOC;
1155}
1156
1157void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) {
1158  VisitExpr(E);
1159  Record.AddSourceLocation(E->getAmpAmpLoc());
1160  Record.AddSourceLocation(E->getLabelLoc());
1161  Record.AddDeclRef(E->getLabel());
1162  Code = serialization::EXPR_ADDR_LABEL;
1163}
1164
1165void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) {
1166  VisitExpr(E);
1167  Record.AddStmt(E->getSubStmt());
1168  Record.AddSourceLocation(E->getLParenLoc());
1169  Record.AddSourceLocation(E->getRParenLoc());
1170  Record.push_back(E->getTemplateDepth());
1171  Code = serialization::EXPR_STMT;
1172}
1173
1174void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) {
1175  VisitExpr(E);
1176  Record.AddStmt(E->getCond());
1177  Record.AddStmt(E->getLHS());
1178  Record.AddStmt(E->getRHS());
1179  Record.AddSourceLocation(E->getBuiltinLoc());
1180  Record.AddSourceLocation(E->getRParenLoc());
1181  Record.push_back(E->isConditionDependent() ? false : E->isConditionTrue());
1182  Code = serialization::EXPR_CHOOSE;
1183}
1184
1185void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) {
1186  VisitExpr(E);
1187  Record.AddSourceLocation(E->getTokenLocation());
1188  Code = serialization::EXPR_GNU_NULL;
1189}
1190
1191void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
1192  VisitExpr(E);
1193  Record.push_back(E->getNumSubExprs());
1194  for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
1195    Record.AddStmt(E->getExpr(I));
1196  Record.AddSourceLocation(E->getBuiltinLoc());
1197  Record.AddSourceLocation(E->getRParenLoc());
1198  Code = serialization::EXPR_SHUFFLE_VECTOR;
1199}
1200
1201void ASTStmtWriter::VisitConvertVectorExpr(ConvertVectorExpr *E) {
1202  VisitExpr(E);
1203  Record.AddSourceLocation(E->getBuiltinLoc());
1204  Record.AddSourceLocation(E->getRParenLoc());
1205  Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1206  Record.AddStmt(E->getSrcExpr());
1207  Code = serialization::EXPR_CONVERT_VECTOR;
1208}
1209
1210void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) {
1211  VisitExpr(E);
1212  Record.AddDeclRef(E->getBlockDecl());
1213  Code = serialization::EXPR_BLOCK;
1214}
1215
1216void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
1217  VisitExpr(E);
1218
1219  Record.push_back(E->getNumAssocs());
1220  Record.push_back(E->ResultIndex);
1221  Record.AddSourceLocation(E->getGenericLoc());
1222  Record.AddSourceLocation(E->getDefaultLoc());
1223  Record.AddSourceLocation(E->getRParenLoc());
1224
1225  Stmt **Stmts = E->getTrailingObjects<Stmt *>();
1226  // Add 1 to account for the controlling expression which is the first
1227  // expression in the trailing array of Stmt *. This is not needed for
1228  // the trailing array of TypeSourceInfo *.
1229  for (unsigned I = 0, N = E->getNumAssocs() + 1; I < N; ++I)
1230    Record.AddStmt(Stmts[I]);
1231
1232  TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>();
1233  for (unsigned I = 0, N = E->getNumAssocs(); I < N; ++I)
1234    Record.AddTypeSourceInfo(TSIs[I]);
1235
1236  Code = serialization::EXPR_GENERIC_SELECTION;
1237}
1238
1239void ASTStmtWriter::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
1240  VisitExpr(E);
1241  Record.push_back(E->getNumSemanticExprs());
1242
1243  // Push the result index.  Currently, this needs to exactly match
1244  // the encoding used internally for ResultIndex.
1245  unsigned result = E->getResultExprIndex();
1246  result = (result == PseudoObjectExpr::NoResult ? 0 : result + 1);
1247  Record.push_back(result);
1248
1249  Record.AddStmt(E->getSyntacticForm());
1250  for (PseudoObjectExpr::semantics_iterator
1251         i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) {
1252    Record.AddStmt(*i);
1253  }
1254  Code = serialization::EXPR_PSEUDO_OBJECT;
1255}
1256
1257void ASTStmtWriter::VisitAtomicExpr(AtomicExpr *E) {
1258  VisitExpr(E);
1259  Record.push_back(E->getOp());
1260  for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
1261    Record.AddStmt(E->getSubExprs()[I]);
1262  Record.AddSourceLocation(E->getBuiltinLoc());
1263  Record.AddSourceLocation(E->getRParenLoc());
1264  Code = serialization::EXPR_ATOMIC;
1265}
1266
1267//===----------------------------------------------------------------------===//
1268// Objective-C Expressions and Statements.
1269//===----------------------------------------------------------------------===//
1270
1271void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) {
1272  VisitExpr(E);
1273  Record.AddStmt(E->getString());
1274  Record.AddSourceLocation(E->getAtLoc());
1275  Code = serialization::EXPR_OBJC_STRING_LITERAL;
1276}
1277
1278void ASTStmtWriter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
1279  VisitExpr(E);
1280  Record.AddStmt(E->getSubExpr());
1281  Record.AddDeclRef(E->getBoxingMethod());
1282  Record.AddSourceRange(E->getSourceRange());
1283  Code = serialization::EXPR_OBJC_BOXED_EXPRESSION;
1284}
1285
1286void ASTStmtWriter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
1287  VisitExpr(E);
1288  Record.push_back(E->getNumElements());
1289  for (unsigned i = 0; i < E->getNumElements(); i++)
1290    Record.AddStmt(E->getElement(i));
1291  Record.AddDeclRef(E->getArrayWithObjectsMethod());
1292  Record.AddSourceRange(E->getSourceRange());
1293  Code = serialization::EXPR_OBJC_ARRAY_LITERAL;
1294}
1295
1296void ASTStmtWriter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
1297  VisitExpr(E);
1298  Record.push_back(E->getNumElements());
1299  Record.push_back(E->HasPackExpansions);
1300  for (unsigned i = 0; i < E->getNumElements(); i++) {
1301    ObjCDictionaryElement Element = E->getKeyValueElement(i);
1302    Record.AddStmt(Element.Key);
1303    Record.AddStmt(Element.Value);
1304    if (E->HasPackExpansions) {
1305      Record.AddSourceLocation(Element.EllipsisLoc);
1306      unsigned NumExpansions = 0;
1307      if (Element.NumExpansions)
1308        NumExpansions = *Element.NumExpansions + 1;
1309      Record.push_back(NumExpansions);
1310    }
1311  }
1312
1313  Record.AddDeclRef(E->getDictWithObjectsMethod());
1314  Record.AddSourceRange(E->getSourceRange());
1315  Code = serialization::EXPR_OBJC_DICTIONARY_LITERAL;
1316}
1317
1318void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
1319  VisitExpr(E);
1320  Record.AddTypeSourceInfo(E->getEncodedTypeSourceInfo());
1321  Record.AddSourceLocation(E->getAtLoc());
1322  Record.AddSourceLocation(E->getRParenLoc());
1323  Code = serialization::EXPR_OBJC_ENCODE;
1324}
1325
1326void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
1327  VisitExpr(E);
1328  Record.AddSelectorRef(E->getSelector());
1329  Record.AddSourceLocation(E->getAtLoc());
1330  Record.AddSourceLocation(E->getRParenLoc());
1331  Code = serialization::EXPR_OBJC_SELECTOR_EXPR;
1332}
1333
1334void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
1335  VisitExpr(E);
1336  Record.AddDeclRef(E->getProtocol());
1337  Record.AddSourceLocation(E->getAtLoc());
1338  Record.AddSourceLocation(E->ProtoLoc);
1339  Record.AddSourceLocation(E->getRParenLoc());
1340  Code = serialization::EXPR_OBJC_PROTOCOL_EXPR;
1341}
1342
1343void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
1344  VisitExpr(E);
1345  Record.AddDeclRef(E->getDecl());
1346  Record.AddSourceLocation(E->getLocation());
1347  Record.AddSourceLocation(E->getOpLoc());
1348  Record.AddStmt(E->getBase());
1349  Record.push_back(E->isArrow());
1350  Record.push_back(E->isFreeIvar());
1351  Code = serialization::EXPR_OBJC_IVAR_REF_EXPR;
1352}
1353
1354void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
1355  VisitExpr(E);
1356  Record.push_back(E->SetterAndMethodRefFlags.getInt());
1357  Record.push_back(E->isImplicitProperty());
1358  if (E->isImplicitProperty()) {
1359    Record.AddDeclRef(E->getImplicitPropertyGetter());
1360    Record.AddDeclRef(E->getImplicitPropertySetter());
1361  } else {
1362    Record.AddDeclRef(E->getExplicitProperty());
1363  }
1364  Record.AddSourceLocation(E->getLocation());
1365  Record.AddSourceLocation(E->getReceiverLocation());
1366  if (E->isObjectReceiver()) {
1367    Record.push_back(0);
1368    Record.AddStmt(E->getBase());
1369  } else if (E->isSuperReceiver()) {
1370    Record.push_back(1);
1371    Record.AddTypeRef(E->getSuperReceiverType());
1372  } else {
1373    Record.push_back(2);
1374    Record.AddDeclRef(E->getClassReceiver());
1375  }
1376
1377  Code = serialization::EXPR_OBJC_PROPERTY_REF_EXPR;
1378}
1379
1380void ASTStmtWriter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1381  VisitExpr(E);
1382  Record.AddSourceLocation(E->getRBracket());
1383  Record.AddStmt(E->getBaseExpr());
1384  Record.AddStmt(E->getKeyExpr());
1385  Record.AddDeclRef(E->getAtIndexMethodDecl());
1386  Record.AddDeclRef(E->setAtIndexMethodDecl());
1387
1388  Code = serialization::EXPR_OBJC_SUBSCRIPT_REF_EXPR;
1389}
1390
1391void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1392  VisitExpr(E);
1393  Record.push_back(E->getNumArgs());
1394  Record.push_back(E->getNumStoredSelLocs());
1395  Record.push_back(E->SelLocsKind);
1396  Record.push_back(E->isDelegateInitCall());
1397  Record.push_back(E->IsImplicit);
1398  Record.push_back((unsigned)E->getReceiverKind()); // FIXME: stable encoding
1399  switch (E->getReceiverKind()) {
1400  case ObjCMessageExpr::Instance:
1401    Record.AddStmt(E->getInstanceReceiver());
1402    break;
1403
1404  case ObjCMessageExpr::Class:
1405    Record.AddTypeSourceInfo(E->getClassReceiverTypeInfo());
1406    break;
1407
1408  case ObjCMessageExpr::SuperClass:
1409  case ObjCMessageExpr::SuperInstance:
1410    Record.AddTypeRef(E->getSuperType());
1411    Record.AddSourceLocation(E->getSuperLoc());
1412    break;
1413  }
1414
1415  if (E->getMethodDecl()) {
1416    Record.push_back(1);
1417    Record.AddDeclRef(E->getMethodDecl());
1418  } else {
1419    Record.push_back(0);
1420    Record.AddSelectorRef(E->getSelector());
1421  }
1422
1423  Record.AddSourceLocation(E->getLeftLoc());
1424  Record.AddSourceLocation(E->getRightLoc());
1425
1426  for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
1427       Arg != ArgEnd; ++Arg)
1428    Record.AddStmt(*Arg);
1429
1430  SourceLocation *Locs = E->getStoredSelLocs();
1431  for (unsigned i = 0, e = E->getNumStoredSelLocs(); i != e; ++i)
1432    Record.AddSourceLocation(Locs[i]);
1433
1434  Code = serialization::EXPR_OBJC_MESSAGE_EXPR;
1435}
1436
1437void ASTStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
1438  VisitStmt(S);
1439  Record.AddStmt(S->getElement());
1440  Record.AddStmt(S->getCollection());
1441  Record.AddStmt(S->getBody());
1442  Record.AddSourceLocation(S->getForLoc());
1443  Record.AddSourceLocation(S->getRParenLoc());
1444  Code = serialization::STMT_OBJC_FOR_COLLECTION;
1445}
1446
1447void ASTStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
1448  VisitStmt(S);
1449  Record.AddStmt(S->getCatchBody());
1450  Record.AddDeclRef(S->getCatchParamDecl());
1451  Record.AddSourceLocation(S->getAtCatchLoc());
1452  Record.AddSourceLocation(S->getRParenLoc());
1453  Code = serialization::STMT_OBJC_CATCH;
1454}
1455
1456void ASTStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
1457  VisitStmt(S);
1458  Record.AddStmt(S->getFinallyBody());
1459  Record.AddSourceLocation(S->getAtFinallyLoc());
1460  Code = serialization::STMT_OBJC_FINALLY;
1461}
1462
1463void ASTStmtWriter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1464  VisitStmt(S); // FIXME: no test coverage.
1465  Record.AddStmt(S->getSubStmt());
1466  Record.AddSourceLocation(S->getAtLoc());
1467  Code = serialization::STMT_OBJC_AUTORELEASE_POOL;
1468}
1469
1470void ASTStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
1471  VisitStmt(S);
1472  Record.push_back(S->getNumCatchStmts());
1473  Record.push_back(S->getFinallyStmt() != nullptr);
1474  Record.AddStmt(S->getTryBody());
1475  for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
1476    Record.AddStmt(S->getCatchStmt(I));
1477  if (S->getFinallyStmt())
1478    Record.AddStmt(S->getFinallyStmt());
1479  Record.AddSourceLocation(S->getAtTryLoc());
1480  Code = serialization::STMT_OBJC_AT_TRY;
1481}
1482
1483void ASTStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1484  VisitStmt(S); // FIXME: no test coverage.
1485  Record.AddStmt(S->getSynchExpr());
1486  Record.AddStmt(S->getSynchBody());
1487  Record.AddSourceLocation(S->getAtSynchronizedLoc());
1488  Code = serialization::STMT_OBJC_AT_SYNCHRONIZED;
1489}
1490
1491void ASTStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
1492  VisitStmt(S); // FIXME: no test coverage.
1493  Record.AddStmt(S->getThrowExpr());
1494  Record.AddSourceLocation(S->getThrowLoc());
1495  Code = serialization::STMT_OBJC_AT_THROW;
1496}
1497
1498void ASTStmtWriter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1499  VisitExpr(E);
1500  Record.push_back(E->getValue());
1501  Record.AddSourceLocation(E->getLocation());
1502  Code = serialization::EXPR_OBJC_BOOL_LITERAL;
1503}
1504
1505void ASTStmtWriter::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
1506  VisitExpr(E);
1507  Record.AddSourceRange(E->getSourceRange());
1508  Record.AddVersionTuple(E->getVersion());
1509  Code = serialization::EXPR_OBJC_AVAILABILITY_CHECK;
1510}
1511
1512//===----------------------------------------------------------------------===//
1513// C++ Expressions and Statements.
1514//===----------------------------------------------------------------------===//
1515
1516void ASTStmtWriter::VisitCXXCatchStmt(CXXCatchStmt *S) {
1517  VisitStmt(S);
1518  Record.AddSourceLocation(S->getCatchLoc());
1519  Record.AddDeclRef(S->getExceptionDecl());
1520  Record.AddStmt(S->getHandlerBlock());
1521  Code = serialization::STMT_CXX_CATCH;
1522}
1523
1524void ASTStmtWriter::VisitCXXTryStmt(CXXTryStmt *S) {
1525  VisitStmt(S);
1526  Record.push_back(S->getNumHandlers());
1527  Record.AddSourceLocation(S->getTryLoc());
1528  Record.AddStmt(S->getTryBlock());
1529  for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1530    Record.AddStmt(S->getHandler(i));
1531  Code = serialization::STMT_CXX_TRY;
1532}
1533
1534void ASTStmtWriter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1535  VisitStmt(S);
1536  Record.AddSourceLocation(S->getForLoc());
1537  Record.AddSourceLocation(S->getCoawaitLoc());
1538  Record.AddSourceLocation(S->getColonLoc());
1539  Record.AddSourceLocation(S->getRParenLoc());
1540  Record.AddStmt(S->getInit());
1541  Record.AddStmt(S->getRangeStmt());
1542  Record.AddStmt(S->getBeginStmt());
1543  Record.AddStmt(S->getEndStmt());
1544  Record.AddStmt(S->getCond());
1545  Record.AddStmt(S->getInc());
1546  Record.AddStmt(S->getLoopVarStmt());
1547  Record.AddStmt(S->getBody());
1548  Code = serialization::STMT_CXX_FOR_RANGE;
1549}
1550
1551void ASTStmtWriter::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1552  VisitStmt(S);
1553  Record.AddSourceLocation(S->getKeywordLoc());
1554  Record.push_back(S->isIfExists());
1555  Record.AddNestedNameSpecifierLoc(S->getQualifierLoc());
1556  Record.AddDeclarationNameInfo(S->getNameInfo());
1557  Record.AddStmt(S->getSubStmt());
1558  Code = serialization::STMT_MS_DEPENDENT_EXISTS;
1559}
1560
1561void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1562  VisitCallExpr(E);
1563  Record.push_back(E->getOperator());
1564  Record.AddSourceRange(E->Range);
1565  Code = serialization::EXPR_CXX_OPERATOR_CALL;
1566}
1567
1568void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1569  VisitCallExpr(E);
1570  Code = serialization::EXPR_CXX_MEMBER_CALL;
1571}
1572
1573void ASTStmtWriter::VisitCXXRewrittenBinaryOperator(
1574    CXXRewrittenBinaryOperator *E) {
1575  VisitExpr(E);
1576  Record.push_back(E->isReversed());
1577  Record.AddStmt(E->getSemanticForm());
1578  Code = serialization::EXPR_CXX_REWRITTEN_BINARY_OPERATOR;
1579}
1580
1581void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) {
1582  VisitExpr(E);
1583
1584  Record.push_back(E->getNumArgs());
1585  Record.push_back(E->isElidable());
1586  Record.push_back(E->hadMultipleCandidates());
1587  Record.push_back(E->isListInitialization());
1588  Record.push_back(E->isStdInitListInitialization());
1589  Record.push_back(E->requiresZeroInitialization());
1590  Record.push_back(E->getConstructionKind()); // FIXME: stable encoding
1591  Record.AddSourceLocation(E->getLocation());
1592  Record.AddDeclRef(E->getConstructor());
1593  Record.AddSourceRange(E->getParenOrBraceRange());
1594
1595  for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1596    Record.AddStmt(E->getArg(I));
1597
1598  Code = serialization::EXPR_CXX_CONSTRUCT;
1599}
1600
1601void ASTStmtWriter::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
1602  VisitExpr(E);
1603  Record.AddDeclRef(E->getConstructor());
1604  Record.AddSourceLocation(E->getLocation());
1605  Record.push_back(E->constructsVBase());
1606  Record.push_back(E->inheritedFromVBase());
1607  Code = serialization::EXPR_CXX_INHERITED_CTOR_INIT;
1608}
1609
1610void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1611  VisitCXXConstructExpr(E);
1612  Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1613  Code = serialization::EXPR_CXX_TEMPORARY_OBJECT;
1614}
1615
1616void ASTStmtWriter::VisitLambdaExpr(LambdaExpr *E) {
1617  VisitExpr(E);
1618  Record.push_back(E->LambdaExprBits.NumCaptures);
1619  Record.AddSourceRange(E->IntroducerRange);
1620  Record.push_back(E->LambdaExprBits.CaptureDefault); // FIXME: stable encoding
1621  Record.AddSourceLocation(E->CaptureDefaultLoc);
1622  Record.push_back(E->LambdaExprBits.ExplicitParams);
1623  Record.push_back(E->LambdaExprBits.ExplicitResultType);
1624  Record.AddSourceLocation(E->ClosingBrace);
1625
1626  // Add capture initializers.
1627  for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1628                                      CEnd = E->capture_init_end();
1629       C != CEnd; ++C) {
1630    Record.AddStmt(*C);
1631  }
1632
1633  // Don't serialize the body. It belongs to the call operator declaration.
1634  // LambdaExpr only stores a copy of the Stmt *.
1635
1636  Code = serialization::EXPR_LAMBDA;
1637}
1638
1639void ASTStmtWriter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1640  VisitExpr(E);
1641  Record.AddStmt(E->getSubExpr());
1642  Code = serialization::EXPR_CXX_STD_INITIALIZER_LIST;
1643}
1644
1645void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1646  VisitExplicitCastExpr(E);
1647  Record.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc()));
1648  Record.AddSourceRange(E->getAngleBrackets());
1649}
1650
1651void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1652  VisitCXXNamedCastExpr(E);
1653  Code = serialization::EXPR_CXX_STATIC_CAST;
1654}
1655
1656void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1657  VisitCXXNamedCastExpr(E);
1658  Code = serialization::EXPR_CXX_DYNAMIC_CAST;
1659}
1660
1661void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1662  VisitCXXNamedCastExpr(E);
1663  Code = serialization::EXPR_CXX_REINTERPRET_CAST;
1664}
1665
1666void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1667  VisitCXXNamedCastExpr(E);
1668  Code = serialization::EXPR_CXX_CONST_CAST;
1669}
1670
1671void ASTStmtWriter::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) {
1672  VisitCXXNamedCastExpr(E);
1673  Code = serialization::EXPR_CXX_ADDRSPACE_CAST;
1674}
1675
1676void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1677  VisitExplicitCastExpr(E);
1678  Record.AddSourceLocation(E->getLParenLoc());
1679  Record.AddSourceLocation(E->getRParenLoc());
1680  Code = serialization::EXPR_CXX_FUNCTIONAL_CAST;
1681}
1682
1683void ASTStmtWriter::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) {
1684  VisitExplicitCastExpr(E);
1685  Record.AddSourceLocation(E->getBeginLoc());
1686  Record.AddSourceLocation(E->getEndLoc());
1687  Code = serialization::EXPR_BUILTIN_BIT_CAST;
1688}
1689
1690void ASTStmtWriter::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1691  VisitCallExpr(E);
1692  Record.AddSourceLocation(E->UDSuffixLoc);
1693  Code = serialization::EXPR_USER_DEFINED_LITERAL;
1694}
1695
1696void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1697  VisitExpr(E);
1698  Record.push_back(E->getValue());
1699  Record.AddSourceLocation(E->getLocation());
1700  Code = serialization::EXPR_CXX_BOOL_LITERAL;
1701}
1702
1703void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1704  VisitExpr(E);
1705  Record.AddSourceLocation(E->getLocation());
1706  Code = serialization::EXPR_CXX_NULL_PTR_LITERAL;
1707}
1708
1709void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1710  VisitExpr(E);
1711  Record.AddSourceRange(E->getSourceRange());
1712  if (E->isTypeOperand()) {
1713    Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo());
1714    Code = serialization::EXPR_CXX_TYPEID_TYPE;
1715  } else {
1716    Record.AddStmt(E->getExprOperand());
1717    Code = serialization::EXPR_CXX_TYPEID_EXPR;
1718  }
1719}
1720
1721void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) {
1722  VisitExpr(E);
1723  Record.AddSourceLocation(E->getLocation());
1724  Record.push_back(E->isImplicit());
1725  Code = serialization::EXPR_CXX_THIS;
1726}
1727
1728void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) {
1729  VisitExpr(E);
1730  Record.AddSourceLocation(E->getThrowLoc());
1731  Record.AddStmt(E->getSubExpr());
1732  Record.push_back(E->isThrownVariableInScope());
1733  Code = serialization::EXPR_CXX_THROW;
1734}
1735
1736void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1737  VisitExpr(E);
1738  Record.AddDeclRef(E->getParam());
1739  Record.AddDeclRef(cast_or_null<Decl>(E->getUsedContext()));
1740  Record.AddSourceLocation(E->getUsedLocation());
1741  Code = serialization::EXPR_CXX_DEFAULT_ARG;
1742}
1743
1744void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1745  VisitExpr(E);
1746  Record.AddDeclRef(E->getField());
1747  Record.AddDeclRef(cast_or_null<Decl>(E->getUsedContext()));
1748  Record.AddSourceLocation(E->getExprLoc());
1749  Code = serialization::EXPR_CXX_DEFAULT_INIT;
1750}
1751
1752void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1753  VisitExpr(E);
1754  Record.AddCXXTemporary(E->getTemporary());
1755  Record.AddStmt(E->getSubExpr());
1756  Code = serialization::EXPR_CXX_BIND_TEMPORARY;
1757}
1758
1759void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1760  VisitExpr(E);
1761  Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1762  Record.AddSourceLocation(E->getRParenLoc());
1763  Code = serialization::EXPR_CXX_SCALAR_VALUE_INIT;
1764}
1765
1766void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) {
1767  VisitExpr(E);
1768
1769  Record.push_back(E->isArray());
1770  Record.push_back(E->hasInitializer());
1771  Record.push_back(E->getNumPlacementArgs());
1772  Record.push_back(E->isParenTypeId());
1773
1774  Record.push_back(E->isGlobalNew());
1775  Record.push_back(E->passAlignment());
1776  Record.push_back(E->doesUsualArrayDeleteWantSize());
1777  Record.push_back(E->CXXNewExprBits.StoredInitializationStyle);
1778
1779  Record.AddDeclRef(E->getOperatorNew());
1780  Record.AddDeclRef(E->getOperatorDelete());
1781  Record.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo());
1782  if (E->isParenTypeId())
1783    Record.AddSourceRange(E->getTypeIdParens());
1784  Record.AddSourceRange(E->getSourceRange());
1785  Record.AddSourceRange(E->getDirectInitRange());
1786
1787  for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), N = E->raw_arg_end();
1788       I != N; ++I)
1789    Record.AddStmt(*I);
1790
1791  Code = serialization::EXPR_CXX_NEW;
1792}
1793
1794void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1795  VisitExpr(E);
1796  Record.push_back(E->isGlobalDelete());
1797  Record.push_back(E->isArrayForm());
1798  Record.push_back(E->isArrayFormAsWritten());
1799  Record.push_back(E->doesUsualArrayDeleteWantSize());
1800  Record.AddDeclRef(E->getOperatorDelete());
1801  Record.AddStmt(E->getArgument());
1802  Record.AddSourceLocation(E->getBeginLoc());
1803
1804  Code = serialization::EXPR_CXX_DELETE;
1805}
1806
1807void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1808  VisitExpr(E);
1809
1810  Record.AddStmt(E->getBase());
1811  Record.push_back(E->isArrow());
1812  Record.AddSourceLocation(E->getOperatorLoc());
1813  Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
1814  Record.AddTypeSourceInfo(E->getScopeTypeInfo());
1815  Record.AddSourceLocation(E->getColonColonLoc());
1816  Record.AddSourceLocation(E->getTildeLoc());
1817
1818  // PseudoDestructorTypeStorage.
1819  Record.AddIdentifierRef(E->getDestroyedTypeIdentifier());
1820  if (E->getDestroyedTypeIdentifier())
1821    Record.AddSourceLocation(E->getDestroyedTypeLoc());
1822  else
1823    Record.AddTypeSourceInfo(E->getDestroyedTypeInfo());
1824
1825  Code = serialization::EXPR_CXX_PSEUDO_DESTRUCTOR;
1826}
1827
1828void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) {
1829  VisitExpr(E);
1830  Record.push_back(E->getNumObjects());
1831  for (auto &Obj : E->getObjects()) {
1832    if (auto *BD = Obj.dyn_cast<BlockDecl *>()) {
1833      Record.push_back(serialization::COK_Block);
1834      Record.AddDeclRef(BD);
1835    } else if (auto *CLE = Obj.dyn_cast<CompoundLiteralExpr *>()) {
1836      Record.push_back(serialization::COK_CompoundLiteral);
1837      Record.AddStmt(CLE);
1838    }
1839  }
1840
1841  Record.push_back(E->cleanupsHaveSideEffects());
1842  Record.AddStmt(E->getSubExpr());
1843  Code = serialization::EXPR_EXPR_WITH_CLEANUPS;
1844}
1845
1846void ASTStmtWriter::VisitCXXDependentScopeMemberExpr(
1847    CXXDependentScopeMemberExpr *E) {
1848  VisitExpr(E);
1849
1850  // Don't emit anything here (or if you do you will have to update
1851  // the corresponding deserialization function).
1852
1853  Record.push_back(E->hasTemplateKWAndArgsInfo());
1854  Record.push_back(E->getNumTemplateArgs());
1855  Record.push_back(E->hasFirstQualifierFoundInScope());
1856
1857  if (E->hasTemplateKWAndArgsInfo()) {
1858    const ASTTemplateKWAndArgsInfo &ArgInfo =
1859        *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
1860    AddTemplateKWAndArgsInfo(ArgInfo,
1861                             E->getTrailingObjects<TemplateArgumentLoc>());
1862  }
1863
1864  Record.push_back(E->isArrow());
1865  Record.AddSourceLocation(E->getOperatorLoc());
1866  Record.AddTypeRef(E->getBaseType());
1867  Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
1868  if (!E->isImplicitAccess())
1869    Record.AddStmt(E->getBase());
1870  else
1871    Record.AddStmt(nullptr);
1872
1873  if (E->hasFirstQualifierFoundInScope())
1874    Record.AddDeclRef(E->getFirstQualifierFoundInScope());
1875
1876  Record.AddDeclarationNameInfo(E->MemberNameInfo);
1877  Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER;
1878}
1879
1880void
1881ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1882  VisitExpr(E);
1883
1884  // Don't emit anything here, HasTemplateKWAndArgsInfo must be
1885  // emitted first.
1886
1887  Record.push_back(E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo);
1888  if (E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo) {
1889    const ASTTemplateKWAndArgsInfo &ArgInfo =
1890        *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
1891    Record.push_back(ArgInfo.NumTemplateArgs);
1892    AddTemplateKWAndArgsInfo(ArgInfo,
1893                             E->getTrailingObjects<TemplateArgumentLoc>());
1894  }
1895
1896  Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
1897  Record.AddDeclarationNameInfo(E->NameInfo);
1898  Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF;
1899}
1900
1901void
1902ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1903  VisitExpr(E);
1904  Record.push_back(E->getNumArgs());
1905  for (CXXUnresolvedConstructExpr::arg_iterator
1906         ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI)
1907    Record.AddStmt(*ArgI);
1908  Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1909  Record.AddSourceLocation(E->getLParenLoc());
1910  Record.AddSourceLocation(E->getRParenLoc());
1911  Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT;
1912}
1913
1914void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) {
1915  VisitExpr(E);
1916
1917  Record.push_back(E->getNumDecls());
1918  Record.push_back(E->hasTemplateKWAndArgsInfo());
1919  if (E->hasTemplateKWAndArgsInfo()) {
1920    const ASTTemplateKWAndArgsInfo &ArgInfo =
1921        *E->getTrailingASTTemplateKWAndArgsInfo();
1922    Record.push_back(ArgInfo.NumTemplateArgs);
1923    AddTemplateKWAndArgsInfo(ArgInfo, E->getTrailingTemplateArgumentLoc());
1924  }
1925
1926  for (OverloadExpr::decls_iterator OvI = E->decls_begin(),
1927                                    OvE = E->decls_end();
1928       OvI != OvE; ++OvI) {
1929    Record.AddDeclRef(OvI.getDecl());
1930    Record.push_back(OvI.getAccess());
1931  }
1932
1933  Record.AddDeclarationNameInfo(E->getNameInfo());
1934  Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
1935}
1936
1937void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1938  VisitOverloadExpr(E);
1939  Record.push_back(E->isArrow());
1940  Record.push_back(E->hasUnresolvedUsing());
1941  Record.AddStmt(!E->isImplicitAccess() ? E->getBase() : nullptr);
1942  Record.AddTypeRef(E->getBaseType());
1943  Record.AddSourceLocation(E->getOperatorLoc());
1944  Code = serialization::EXPR_CXX_UNRESOLVED_MEMBER;
1945}
1946
1947void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1948  VisitOverloadExpr(E);
1949  Record.push_back(E->requiresADL());
1950  Record.push_back(E->isOverloaded());
1951  Record.AddDeclRef(E->getNamingClass());
1952  Code = serialization::EXPR_CXX_UNRESOLVED_LOOKUP;
1953}
1954
1955void ASTStmtWriter::VisitTypeTraitExpr(TypeTraitExpr *E) {
1956  VisitExpr(E);
1957  Record.push_back(E->TypeTraitExprBits.NumArgs);
1958  Record.push_back(E->TypeTraitExprBits.Kind); // FIXME: Stable encoding
1959  Record.push_back(E->TypeTraitExprBits.Value);
1960  Record.AddSourceRange(E->getSourceRange());
1961  for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1962    Record.AddTypeSourceInfo(E->getArg(I));
1963  Code = serialization::EXPR_TYPE_TRAIT;
1964}
1965
1966void ASTStmtWriter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1967  VisitExpr(E);
1968  Record.push_back(E->getTrait());
1969  Record.push_back(E->getValue());
1970  Record.AddSourceRange(E->getSourceRange());
1971  Record.AddTypeSourceInfo(E->getQueriedTypeSourceInfo());
1972  Record.AddStmt(E->getDimensionExpression());
1973  Code = serialization::EXPR_ARRAY_TYPE_TRAIT;
1974}
1975
1976void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1977  VisitExpr(E);
1978  Record.push_back(E->getTrait());
1979  Record.push_back(E->getValue());
1980  Record.AddSourceRange(E->getSourceRange());
1981  Record.AddStmt(E->getQueriedExpression());
1982  Code = serialization::EXPR_CXX_EXPRESSION_TRAIT;
1983}
1984
1985void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1986  VisitExpr(E);
1987  Record.push_back(E->getValue());
1988  Record.AddSourceRange(E->getSourceRange());
1989  Record.AddStmt(E->getOperand());
1990  Code = serialization::EXPR_CXX_NOEXCEPT;
1991}
1992
1993void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) {
1994  VisitExpr(E);
1995  Record.AddSourceLocation(E->getEllipsisLoc());
1996  Record.push_back(E->NumExpansions);
1997  Record.AddStmt(E->getPattern());
1998  Code = serialization::EXPR_PACK_EXPANSION;
1999}
2000
2001void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
2002  VisitExpr(E);
2003  Record.push_back(E->isPartiallySubstituted() ? E->getPartialArguments().size()
2004                                               : 0);
2005  Record.AddSourceLocation(E->OperatorLoc);
2006  Record.AddSourceLocation(E->PackLoc);
2007  Record.AddSourceLocation(E->RParenLoc);
2008  Record.AddDeclRef(E->Pack);
2009  if (E->isPartiallySubstituted()) {
2010    for (const auto &TA : E->getPartialArguments())
2011      Record.AddTemplateArgument(TA);
2012  } else if (!E->isValueDependent()) {
2013    Record.push_back(E->getPackLength());
2014  }
2015  Code = serialization::EXPR_SIZEOF_PACK;
2016}
2017
2018void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr(
2019                                              SubstNonTypeTemplateParmExpr *E) {
2020  VisitExpr(E);
2021  Record.AddDeclRef(E->getParameter());
2022  Record.push_back(E->isReferenceParameter());
2023  Record.AddSourceLocation(E->getNameLoc());
2024  Record.AddStmt(E->getReplacement());
2025  Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM;
2026}
2027
2028void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr(
2029                                          SubstNonTypeTemplateParmPackExpr *E) {
2030  VisitExpr(E);
2031  Record.AddDeclRef(E->getParameterPack());
2032  Record.AddTemplateArgument(E->getArgumentPack());
2033  Record.AddSourceLocation(E->getParameterPackLocation());
2034  Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK;
2035}
2036
2037void ASTStmtWriter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
2038  VisitExpr(E);
2039  Record.push_back(E->getNumExpansions());
2040  Record.AddDeclRef(E->getParameterPack());
2041  Record.AddSourceLocation(E->getParameterPackLocation());
2042  for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end();
2043       I != End; ++I)
2044    Record.AddDeclRef(*I);
2045  Code = serialization::EXPR_FUNCTION_PARM_PACK;
2046}
2047
2048void ASTStmtWriter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
2049  VisitExpr(E);
2050  Record.push_back(static_cast<bool>(E->getLifetimeExtendedTemporaryDecl()));
2051  if (E->getLifetimeExtendedTemporaryDecl())
2052    Record.AddDeclRef(E->getLifetimeExtendedTemporaryDecl());
2053  else
2054    Record.AddStmt(E->getSubExpr());
2055  Code = serialization::EXPR_MATERIALIZE_TEMPORARY;
2056}
2057
2058void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) {
2059  VisitExpr(E);
2060  Record.AddSourceLocation(E->LParenLoc);
2061  Record.AddSourceLocation(E->EllipsisLoc);
2062  Record.AddSourceLocation(E->RParenLoc);
2063  Record.push_back(E->NumExpansions);
2064  Record.AddStmt(E->SubExprs[0]);
2065  Record.AddStmt(E->SubExprs[1]);
2066  Record.AddStmt(E->SubExprs[2]);
2067  Record.push_back(E->Opcode);
2068  Code = serialization::EXPR_CXX_FOLD;
2069}
2070
2071void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
2072  VisitExpr(E);
2073  Record.AddStmt(E->getSourceExpr());
2074  Record.AddSourceLocation(E->getLocation());
2075  Record.push_back(E->isUnique());
2076  Code = serialization::EXPR_OPAQUE_VALUE;
2077}
2078
2079void ASTStmtWriter::VisitTypoExpr(TypoExpr *E) {
2080  VisitExpr(E);
2081  // TODO: Figure out sane writer behavior for a TypoExpr, if necessary
2082  llvm_unreachable("Cannot write TypoExpr nodes");
2083}
2084
2085//===----------------------------------------------------------------------===//
2086// CUDA Expressions and Statements.
2087//===----------------------------------------------------------------------===//
2088
2089void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
2090  VisitCallExpr(E);
2091  Record.AddStmt(E->getConfig());
2092  Code = serialization::EXPR_CUDA_KERNEL_CALL;
2093}
2094
2095//===----------------------------------------------------------------------===//
2096// OpenCL Expressions and Statements.
2097//===----------------------------------------------------------------------===//
2098void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) {
2099  VisitExpr(E);
2100  Record.AddSourceLocation(E->getBuiltinLoc());
2101  Record.AddSourceLocation(E->getRParenLoc());
2102  Record.AddStmt(E->getSrcExpr());
2103  Code = serialization::EXPR_ASTYPE;
2104}
2105
2106//===----------------------------------------------------------------------===//
2107// Microsoft Expressions and Statements.
2108//===----------------------------------------------------------------------===//
2109void ASTStmtWriter::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
2110  VisitExpr(E);
2111  Record.push_back(E->isArrow());
2112  Record.AddStmt(E->getBaseExpr());
2113  Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
2114  Record.AddSourceLocation(E->getMemberLoc());
2115  Record.AddDeclRef(E->getPropertyDecl());
2116  Code = serialization::EXPR_CXX_PROPERTY_REF_EXPR;
2117}
2118
2119void ASTStmtWriter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
2120  VisitExpr(E);
2121  Record.AddStmt(E->getBase());
2122  Record.AddStmt(E->getIdx());
2123  Record.AddSourceLocation(E->getRBracketLoc());
2124  Code = serialization::EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR;
2125}
2126
2127void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
2128  VisitExpr(E);
2129  Record.AddSourceRange(E->getSourceRange());
2130  Record.AddDeclRef(E->getGuidDecl());
2131  if (E->isTypeOperand()) {
2132    Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo());
2133    Code = serialization::EXPR_CXX_UUIDOF_TYPE;
2134  } else {
2135    Record.AddStmt(E->getExprOperand());
2136    Code = serialization::EXPR_CXX_UUIDOF_EXPR;
2137  }
2138}
2139
2140void ASTStmtWriter::VisitSEHExceptStmt(SEHExceptStmt *S) {
2141  VisitStmt(S);
2142  Record.AddSourceLocation(S->getExceptLoc());
2143  Record.AddStmt(S->getFilterExpr());
2144  Record.AddStmt(S->getBlock());
2145  Code = serialization::STMT_SEH_EXCEPT;
2146}
2147
2148void ASTStmtWriter::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
2149  VisitStmt(S);
2150  Record.AddSourceLocation(S->getFinallyLoc());
2151  Record.AddStmt(S->getBlock());
2152  Code = serialization::STMT_SEH_FINALLY;
2153}
2154
2155void ASTStmtWriter::VisitSEHTryStmt(SEHTryStmt *S) {
2156  VisitStmt(S);
2157  Record.push_back(S->getIsCXXTry());
2158  Record.AddSourceLocation(S->getTryLoc());
2159  Record.AddStmt(S->getTryBlock());
2160  Record.AddStmt(S->getHandler());
2161  Code = serialization::STMT_SEH_TRY;
2162}
2163
2164void ASTStmtWriter::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
2165  VisitStmt(S);
2166  Record.AddSourceLocation(S->getLeaveLoc());
2167  Code = serialization::STMT_SEH_LEAVE;
2168}
2169
2170//===----------------------------------------------------------------------===//
2171// OpenMP Directives.
2172//===----------------------------------------------------------------------===//
2173
2174void ASTStmtWriter::VisitOMPCanonicalLoop(OMPCanonicalLoop *S) {
2175  VisitStmt(S);
2176  for (Stmt *SubStmt : S->SubStmts)
2177    Record.AddStmt(SubStmt);
2178  Code = serialization::STMT_OMP_CANONICAL_LOOP;
2179}
2180
2181void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2182  Record.writeOMPChildren(E->Data);
2183  Record.AddSourceLocation(E->getBeginLoc());
2184  Record.AddSourceLocation(E->getEndLoc());
2185}
2186
2187void ASTStmtWriter::VisitOMPLoopBasedDirective(OMPLoopBasedDirective *D) {
2188  VisitStmt(D);
2189  Record.writeUInt32(D->getLoopsNumber());
2190  VisitOMPExecutableDirective(D);
2191}
2192
2193void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) {
2194  VisitOMPLoopBasedDirective(D);
2195}
2196
2197void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) {
2198  VisitStmt(D);
2199  VisitOMPExecutableDirective(D);
2200  Record.writeBool(D->hasCancel());
2201  Code = serialization::STMT_OMP_PARALLEL_DIRECTIVE;
2202}
2203
2204void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) {
2205  VisitOMPLoopDirective(D);
2206  Code = serialization::STMT_OMP_SIMD_DIRECTIVE;
2207}
2208
2209void ASTStmtWriter::VisitOMPTileDirective(OMPTileDirective *D) {
2210  VisitOMPLoopBasedDirective(D);
2211  Code = serialization::STMT_OMP_TILE_DIRECTIVE;
2212}
2213
2214void ASTStmtWriter::VisitOMPForDirective(OMPForDirective *D) {
2215  VisitOMPLoopDirective(D);
2216  Record.writeBool(D->hasCancel());
2217  Code = serialization::STMT_OMP_FOR_DIRECTIVE;
2218}
2219
2220void ASTStmtWriter::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
2221  VisitOMPLoopDirective(D);
2222  Code = serialization::STMT_OMP_FOR_SIMD_DIRECTIVE;
2223}
2224
2225void ASTStmtWriter::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
2226  VisitStmt(D);
2227  VisitOMPExecutableDirective(D);
2228  Record.writeBool(D->hasCancel());
2229  Code = serialization::STMT_OMP_SECTIONS_DIRECTIVE;
2230}
2231
2232void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) {
2233  VisitStmt(D);
2234  VisitOMPExecutableDirective(D);
2235  Record.writeBool(D->hasCancel());
2236  Code = serialization::STMT_OMP_SECTION_DIRECTIVE;
2237}
2238
2239void ASTStmtWriter::VisitOMPSingleDirective(OMPSingleDirective *D) {
2240  VisitStmt(D);
2241  VisitOMPExecutableDirective(D);
2242  Code = serialization::STMT_OMP_SINGLE_DIRECTIVE;
2243}
2244
2245void ASTStmtWriter::VisitOMPMasterDirective(OMPMasterDirective *D) {
2246  VisitStmt(D);
2247  VisitOMPExecutableDirective(D);
2248  Code = serialization::STMT_OMP_MASTER_DIRECTIVE;
2249}
2250
2251void ASTStmtWriter::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2252  VisitStmt(D);
2253  VisitOMPExecutableDirective(D);
2254  Record.AddDeclarationNameInfo(D->getDirectiveName());
2255  Code = serialization::STMT_OMP_CRITICAL_DIRECTIVE;
2256}
2257
2258void ASTStmtWriter::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2259  VisitOMPLoopDirective(D);
2260  Record.writeBool(D->hasCancel());
2261  Code = serialization::STMT_OMP_PARALLEL_FOR_DIRECTIVE;
2262}
2263
2264void ASTStmtWriter::VisitOMPParallelForSimdDirective(
2265    OMPParallelForSimdDirective *D) {
2266  VisitOMPLoopDirective(D);
2267  Code = serialization::STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE;
2268}
2269
2270void ASTStmtWriter::VisitOMPParallelMasterDirective(
2271    OMPParallelMasterDirective *D) {
2272  VisitStmt(D);
2273  VisitOMPExecutableDirective(D);
2274  Code = serialization::STMT_OMP_PARALLEL_MASTER_DIRECTIVE;
2275}
2276
2277void ASTStmtWriter::VisitOMPParallelSectionsDirective(
2278    OMPParallelSectionsDirective *D) {
2279  VisitStmt(D);
2280  VisitOMPExecutableDirective(D);
2281  Record.writeBool(D->hasCancel());
2282  Code = serialization::STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE;
2283}
2284
2285void ASTStmtWriter::VisitOMPTaskDirective(OMPTaskDirective *D) {
2286  VisitStmt(D);
2287  VisitOMPExecutableDirective(D);
2288  Record.writeBool(D->hasCancel());
2289  Code = serialization::STMT_OMP_TASK_DIRECTIVE;
2290}
2291
2292void ASTStmtWriter::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
2293  VisitStmt(D);
2294  VisitOMPExecutableDirective(D);
2295  Record.writeBool(D->isXLHSInRHSPart());
2296  Record.writeBool(D->isPostfixUpdate());
2297  Code = serialization::STMT_OMP_ATOMIC_DIRECTIVE;
2298}
2299
2300void ASTStmtWriter::VisitOMPTargetDirective(OMPTargetDirective *D) {
2301  VisitStmt(D);
2302  VisitOMPExecutableDirective(D);
2303  Code = serialization::STMT_OMP_TARGET_DIRECTIVE;
2304}
2305
2306void ASTStmtWriter::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
2307  VisitStmt(D);
2308  VisitOMPExecutableDirective(D);
2309  Code = serialization::STMT_OMP_TARGET_DATA_DIRECTIVE;
2310}
2311
2312void ASTStmtWriter::VisitOMPTargetEnterDataDirective(
2313    OMPTargetEnterDataDirective *D) {
2314  VisitStmt(D);
2315  VisitOMPExecutableDirective(D);
2316  Code = serialization::STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE;
2317}
2318
2319void ASTStmtWriter::VisitOMPTargetExitDataDirective(
2320    OMPTargetExitDataDirective *D) {
2321  VisitStmt(D);
2322  VisitOMPExecutableDirective(D);
2323  Code = serialization::STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE;
2324}
2325
2326void ASTStmtWriter::VisitOMPTargetParallelDirective(
2327    OMPTargetParallelDirective *D) {
2328  VisitStmt(D);
2329  VisitOMPExecutableDirective(D);
2330  Record.writeBool(D->hasCancel());
2331  Code = serialization::STMT_OMP_TARGET_PARALLEL_DIRECTIVE;
2332}
2333
2334void ASTStmtWriter::VisitOMPTargetParallelForDirective(
2335    OMPTargetParallelForDirective *D) {
2336  VisitOMPLoopDirective(D);
2337  Record.writeBool(D->hasCancel());
2338  Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE;
2339}
2340
2341void ASTStmtWriter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2342  VisitStmt(D);
2343  VisitOMPExecutableDirective(D);
2344  Code = serialization::STMT_OMP_TASKYIELD_DIRECTIVE;
2345}
2346
2347void ASTStmtWriter::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2348  VisitStmt(D);
2349  VisitOMPExecutableDirective(D);
2350  Code = serialization::STMT_OMP_BARRIER_DIRECTIVE;
2351}
2352
2353void ASTStmtWriter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2354  VisitStmt(D);
2355  VisitOMPExecutableDirective(D);
2356  Code = serialization::STMT_OMP_TASKWAIT_DIRECTIVE;
2357}
2358
2359void ASTStmtWriter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
2360  VisitStmt(D);
2361  VisitOMPExecutableDirective(D);
2362  Code = serialization::STMT_OMP_TASKGROUP_DIRECTIVE;
2363}
2364
2365void ASTStmtWriter::VisitOMPFlushDirective(OMPFlushDirective *D) {
2366  VisitStmt(D);
2367  VisitOMPExecutableDirective(D);
2368  Code = serialization::STMT_OMP_FLUSH_DIRECTIVE;
2369}
2370
2371void ASTStmtWriter::VisitOMPDepobjDirective(OMPDepobjDirective *D) {
2372  VisitStmt(D);
2373  VisitOMPExecutableDirective(D);
2374  Code = serialization::STMT_OMP_DEPOBJ_DIRECTIVE;
2375}
2376
2377void ASTStmtWriter::VisitOMPScanDirective(OMPScanDirective *D) {
2378  VisitStmt(D);
2379  VisitOMPExecutableDirective(D);
2380  Code = serialization::STMT_OMP_SCAN_DIRECTIVE;
2381}
2382
2383void ASTStmtWriter::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
2384  VisitStmt(D);
2385  VisitOMPExecutableDirective(D);
2386  Code = serialization::STMT_OMP_ORDERED_DIRECTIVE;
2387}
2388
2389void ASTStmtWriter::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2390  VisitStmt(D);
2391  VisitOMPExecutableDirective(D);
2392  Code = serialization::STMT_OMP_TEAMS_DIRECTIVE;
2393}
2394
2395void ASTStmtWriter::VisitOMPCancellationPointDirective(
2396    OMPCancellationPointDirective *D) {
2397  VisitStmt(D);
2398  VisitOMPExecutableDirective(D);
2399  Record.writeEnum(D->getCancelRegion());
2400  Code = serialization::STMT_OMP_CANCELLATION_POINT_DIRECTIVE;
2401}
2402
2403void ASTStmtWriter::VisitOMPCancelDirective(OMPCancelDirective *D) {
2404  VisitStmt(D);
2405  VisitOMPExecutableDirective(D);
2406  Record.writeEnum(D->getCancelRegion());
2407  Code = serialization::STMT_OMP_CANCEL_DIRECTIVE;
2408}
2409
2410void ASTStmtWriter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
2411  VisitOMPLoopDirective(D);
2412  Record.writeBool(D->hasCancel());
2413  Code = serialization::STMT_OMP_TASKLOOP_DIRECTIVE;
2414}
2415
2416void ASTStmtWriter::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
2417  VisitOMPLoopDirective(D);
2418  Code = serialization::STMT_OMP_TASKLOOP_SIMD_DIRECTIVE;
2419}
2420
2421void ASTStmtWriter::VisitOMPMasterTaskLoopDirective(
2422    OMPMasterTaskLoopDirective *D) {
2423  VisitOMPLoopDirective(D);
2424  Record.writeBool(D->hasCancel());
2425  Code = serialization::STMT_OMP_MASTER_TASKLOOP_DIRECTIVE;
2426}
2427
2428void ASTStmtWriter::VisitOMPMasterTaskLoopSimdDirective(
2429    OMPMasterTaskLoopSimdDirective *D) {
2430  VisitOMPLoopDirective(D);
2431  Code = serialization::STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE;
2432}
2433
2434void ASTStmtWriter::VisitOMPParallelMasterTaskLoopDirective(
2435    OMPParallelMasterTaskLoopDirective *D) {
2436  VisitOMPLoopDirective(D);
2437  Record.writeBool(D->hasCancel());
2438  Code = serialization::STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE;
2439}
2440
2441void ASTStmtWriter::VisitOMPParallelMasterTaskLoopSimdDirective(
2442    OMPParallelMasterTaskLoopSimdDirective *D) {
2443  VisitOMPLoopDirective(D);
2444  Code = serialization::STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE;
2445}
2446
2447void ASTStmtWriter::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
2448  VisitOMPLoopDirective(D);
2449  Code = serialization::STMT_OMP_DISTRIBUTE_DIRECTIVE;
2450}
2451
2452void ASTStmtWriter::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) {
2453  VisitStmt(D);
2454  VisitOMPExecutableDirective(D);
2455  Code = serialization::STMT_OMP_TARGET_UPDATE_DIRECTIVE;
2456}
2457
2458void ASTStmtWriter::VisitOMPDistributeParallelForDirective(
2459    OMPDistributeParallelForDirective *D) {
2460  VisitOMPLoopDirective(D);
2461  Record.writeBool(D->hasCancel());
2462  Code = serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
2463}
2464
2465void ASTStmtWriter::VisitOMPDistributeParallelForSimdDirective(
2466    OMPDistributeParallelForSimdDirective *D) {
2467  VisitOMPLoopDirective(D);
2468  Code = serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;
2469}
2470
2471void ASTStmtWriter::VisitOMPDistributeSimdDirective(
2472    OMPDistributeSimdDirective *D) {
2473  VisitOMPLoopDirective(D);
2474  Code = serialization::STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE;
2475}
2476
2477void ASTStmtWriter::VisitOMPTargetParallelForSimdDirective(
2478    OMPTargetParallelForSimdDirective *D) {
2479  VisitOMPLoopDirective(D);
2480  Code = serialization::STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE;
2481}
2482
2483void ASTStmtWriter::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) {
2484  VisitOMPLoopDirective(D);
2485  Code = serialization::STMT_OMP_TARGET_SIMD_DIRECTIVE;
2486}
2487
2488void ASTStmtWriter::VisitOMPTeamsDistributeDirective(
2489    OMPTeamsDistributeDirective *D) {
2490  VisitOMPLoopDirective(D);
2491  Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE;
2492}
2493
2494void ASTStmtWriter::VisitOMPTeamsDistributeSimdDirective(
2495    OMPTeamsDistributeSimdDirective *D) {
2496  VisitOMPLoopDirective(D);
2497  Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE;
2498}
2499
2500void ASTStmtWriter::VisitOMPTeamsDistributeParallelForSimdDirective(
2501    OMPTeamsDistributeParallelForSimdDirective *D) {
2502  VisitOMPLoopDirective(D);
2503  Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;
2504}
2505
2506void ASTStmtWriter::VisitOMPTeamsDistributeParallelForDirective(
2507    OMPTeamsDistributeParallelForDirective *D) {
2508  VisitOMPLoopDirective(D);
2509  Record.writeBool(D->hasCancel());
2510  Code = serialization::STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
2511}
2512
2513void ASTStmtWriter::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) {
2514  VisitStmt(D);
2515  VisitOMPExecutableDirective(D);
2516  Code = serialization::STMT_OMP_TARGET_TEAMS_DIRECTIVE;
2517}
2518
2519void ASTStmtWriter::VisitOMPTargetTeamsDistributeDirective(
2520    OMPTargetTeamsDistributeDirective *D) {
2521  VisitOMPLoopDirective(D);
2522  Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE;
2523}
2524
2525void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForDirective(
2526    OMPTargetTeamsDistributeParallelForDirective *D) {
2527  VisitOMPLoopDirective(D);
2528  Record.writeBool(D->hasCancel());
2529  Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE;
2530}
2531
2532void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
2533    OMPTargetTeamsDistributeParallelForSimdDirective *D) {
2534  VisitOMPLoopDirective(D);
2535  Code = serialization::
2536      STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;
2537}
2538
2539void ASTStmtWriter::VisitOMPTargetTeamsDistributeSimdDirective(
2540    OMPTargetTeamsDistributeSimdDirective *D) {
2541  VisitOMPLoopDirective(D);
2542  Code = serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE;
2543}
2544
2545void ASTStmtWriter::VisitOMPInteropDirective(OMPInteropDirective *D) {
2546  VisitStmt(D);
2547  VisitOMPExecutableDirective(D);
2548  Code = serialization::STMT_OMP_INTEROP_DIRECTIVE;
2549}
2550
2551void ASTStmtWriter::VisitOMPDispatchDirective(OMPDispatchDirective *D) {
2552  VisitStmt(D);
2553  VisitOMPExecutableDirective(D);
2554  Record.AddSourceLocation(D->getTargetCallLoc());
2555  Code = serialization::STMT_OMP_DISPATCH_DIRECTIVE;
2556}
2557
2558void ASTStmtWriter::VisitOMPMaskedDirective(OMPMaskedDirective *D) {
2559  VisitStmt(D);
2560  VisitOMPExecutableDirective(D);
2561  Code = serialization::STMT_OMP_MASKED_DIRECTIVE;
2562}
2563
2564//===----------------------------------------------------------------------===//
2565// ASTWriter Implementation
2566//===----------------------------------------------------------------------===//
2567
2568unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) {
2569  assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() &&
2570         "SwitchCase recorded twice");
2571  unsigned NextID = SwitchCaseIDs.size();
2572  SwitchCaseIDs[S] = NextID;
2573  return NextID;
2574}
2575
2576unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) {
2577  assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() &&
2578         "SwitchCase hasn't been seen yet");
2579  return SwitchCaseIDs[S];
2580}
2581
2582void ASTWriter::ClearSwitchCaseIDs() {
2583  SwitchCaseIDs.clear();
2584}
2585
2586/// Write the given substatement or subexpression to the
2587/// bitstream.
2588void ASTWriter::WriteSubStmt(Stmt *S) {
2589  RecordData Record;
2590  ASTStmtWriter Writer(*this, Record);
2591  ++NumStatements;
2592
2593  if (!S) {
2594    Stream.EmitRecord(serialization::STMT_NULL_PTR, Record);
2595    return;
2596  }
2597
2598  llvm::DenseMap<Stmt *, uint64_t>::iterator I = SubStmtEntries.find(S);
2599  if (I != SubStmtEntries.end()) {
2600    Record.push_back(I->second);
2601    Stream.EmitRecord(serialization::STMT_REF_PTR, Record);
2602    return;
2603  }
2604
2605#ifndef NDEBUG
2606  assert(!ParentStmts.count(S) && "There is a Stmt cycle!");
2607
2608  struct ParentStmtInserterRAII {
2609    Stmt *S;
2610    llvm::DenseSet<Stmt *> &ParentStmts;
2611
2612    ParentStmtInserterRAII(Stmt *S, llvm::DenseSet<Stmt *> &ParentStmts)
2613      : S(S), ParentStmts(ParentStmts) {
2614      ParentStmts.insert(S);
2615    }
2616    ~ParentStmtInserterRAII() {
2617      ParentStmts.erase(S);
2618    }
2619  };
2620
2621  ParentStmtInserterRAII ParentStmtInserter(S, ParentStmts);
2622#endif
2623
2624  Writer.Visit(S);
2625
2626  uint64_t Offset = Writer.Emit();
2627  SubStmtEntries[S] = Offset;
2628}
2629
2630/// Flush all of the statements that have been added to the
2631/// queue via AddStmt().
2632void ASTRecordWriter::FlushStmts() {
2633  // We expect to be the only consumer of the two temporary statement maps,
2634  // assert that they are empty.
2635  assert(Writer->SubStmtEntries.empty() && "unexpected entries in sub-stmt map");
2636  assert(Writer->ParentStmts.empty() && "unexpected entries in parent stmt map");
2637
2638  for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
2639    Writer->WriteSubStmt(StmtsToEmit[I]);
2640
2641    assert(N == StmtsToEmit.size() && "record modified while being written!");
2642
2643    // Note that we are at the end of a full expression. Any
2644    // expression records that follow this one are part of a different
2645    // expression.
2646    Writer->Stream.EmitRecord(serialization::STMT_STOP, ArrayRef<uint32_t>());
2647
2648    Writer->SubStmtEntries.clear();
2649    Writer->ParentStmts.clear();
2650  }
2651
2652  StmtsToEmit.clear();
2653}
2654
2655void ASTRecordWriter::FlushSubStmts() {
2656  // For a nested statement, write out the substatements in reverse order (so
2657  // that a simple stack machine can be used when loading), and don't emit a
2658  // STMT_STOP after each one.
2659  for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
2660    Writer->WriteSubStmt(StmtsToEmit[N - I - 1]);
2661    assert(N == StmtsToEmit.size() && "record modified while being written!");
2662  }
2663
2664  StmtsToEmit.clear();
2665}
2666