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