1	//===- ASTReaderStmt.cpp - Stmt/Expr Deserialization ----------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8	//
9	// Statement/expression deserialization. This implements the
10	// ASTReader::ReadStmt method.
11	//
12	//===----------------------------------------------------------------------===//
13
14	#include "clang/AST/ASTConcept.h"
15	#include "clang/AST/ASTContext.h"
16	#include "clang/AST/AttrIterator.h"
17	#include "clang/AST/Decl.h"
18	#include "clang/AST/DeclAccessPair.h"
19	#include "clang/AST/DeclCXX.h"
20	#include "clang/AST/DeclGroup.h"
21	#include "clang/AST/DeclObjC.h"
22	#include "clang/AST/DeclTemplate.h"
23	#include "clang/AST/DeclarationName.h"
24	#include "clang/AST/DependenceFlags.h"
25	#include "clang/AST/Expr.h"
26	#include "clang/AST/ExprCXX.h"
27	#include "clang/AST/ExprObjC.h"
28	#include "clang/AST/ExprOpenMP.h"
29	#include "clang/AST/NestedNameSpecifier.h"
30	#include "clang/AST/OpenMPClause.h"
31	#include "clang/AST/OperationKinds.h"
32	#include "clang/AST/Stmt.h"
33	#include "clang/AST/StmtCXX.h"
34	#include "clang/AST/StmtObjC.h"
35	#include "clang/AST/StmtOpenMP.h"
36	#include "clang/AST/StmtSYCL.h"
37	#include "clang/AST/StmtVisitor.h"
38	#include "clang/AST/TemplateBase.h"
39	#include "clang/AST/Type.h"
40	#include "clang/AST/UnresolvedSet.h"
41	#include "clang/Basic/CapturedStmt.h"
42	#include "clang/Basic/ExpressionTraits.h"
43	#include "clang/Basic/LLVM.h"
44	#include "clang/Basic/LangOptions.h"
45	#include "clang/Basic/OpenMPKinds.h"
46	#include "clang/Basic/SourceLocation.h"
47	#include "clang/Basic/Specifiers.h"
48	#include "clang/Basic/TypeTraits.h"
49	#include "clang/Lex/Token.h"
50	#include "clang/Serialization/ASTBitCodes.h"
51	#include "clang/Serialization/ASTRecordReader.h"
52	#include "llvm/ADT/DenseMap.h"
53	#include "llvm/ADT/SmallVector.h"
54	#include "llvm/ADT/StringRef.h"
55	#include "llvm/Bitstream/BitstreamReader.h"
56	#include "llvm/Support/ErrorHandling.h"
57	#include <algorithm>
58	#include <cassert>
59	#include <cstdint>
60	#include <optional>
61	#include <string>
62
63	using namespace clang;
64	using namespace serialization;
65
66	namespace clang {
67
68	class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
69	ASTRecordReader &Record;
70	llvm::BitstreamCursor &DeclsCursor;
71
72	std::optional<BitsUnpacker> CurrentUnpackingBits;
73
74	SourceLocation readSourceLocation() {
75	return Record.readSourceLocation();
76	}
77
78	SourceRange readSourceRange() {
79	return Record.readSourceRange();
80	}
81
82	std::string readString() {
83	return Record.readString();
84	}
85
86	TypeSourceInfo *readTypeSourceInfo() {
87	return Record.readTypeSourceInfo();
88	}
89
90	Decl *readDecl() {
91	return Record.readDecl();
92	}
93
94	template<typename T>
95	T *readDeclAs() {
96	return Record.readDeclAs<T>();
97	}
98
99	public:
100	ASTStmtReader(ASTRecordReader &Record, llvm::BitstreamCursor &Cursor)
101	: Record(Record), DeclsCursor(Cursor) {}
102
103	/// The number of record fields required for the Stmt class
104	/// itself.
105	static const unsigned NumStmtFields = 0;
106
107	/// The number of record fields required for the Expr class
108	/// itself.
109	static const unsigned NumExprFields = NumStmtFields + 2;
110
111	/// The number of bits required for the packing bits for the Expr class.
112	static const unsigned NumExprBits = 10;
113
114	/// Read and initialize a ExplicitTemplateArgumentList structure.
115	void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
116	TemplateArgumentLoc *ArgsLocArray,
117	unsigned NumTemplateArgs);
118
119	void VisitStmt(Stmt *S);
120	#define STMT(Type, Base) \
121	void Visit##Type(Type *);
122	#include "clang/AST/StmtNodes.inc"
123	};
124
125	} // namespace clang
126
127	void ASTStmtReader::ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
128	TemplateArgumentLoc *ArgsLocArray,
129	unsigned NumTemplateArgs) {
130	SourceLocation TemplateKWLoc = readSourceLocation();
131	TemplateArgumentListInfo ArgInfo;
132	ArgInfo.setLAngleLoc(readSourceLocation());
133	ArgInfo.setRAngleLoc(readSourceLocation());
134	for (unsigned i = 0; i != NumTemplateArgs; ++i)
135	ArgInfo.addArgument(Loc: Record.readTemplateArgumentLoc());
136	Args.initializeFrom(TemplateKWLoc, List: ArgInfo, OutArgArray: ArgsLocArray);
137	}
138
139	void ASTStmtReader::VisitStmt(Stmt *S) {
140	assert(Record.getIdx() == NumStmtFields && "Incorrect statement field count");
141	}
142
143	void ASTStmtReader::VisitNullStmt(NullStmt *S) {
144	VisitStmt(S);
145	S->setSemiLoc(readSourceLocation());
146	S->NullStmtBits.HasLeadingEmptyMacro = Record.readInt();
147	}
148
149	void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
150	VisitStmt(S);
151	SmallVector<Stmt *, 16> Stmts;
152	unsigned NumStmts = Record.readInt();
153	unsigned HasFPFeatures = Record.readInt();
154	assert(S->hasStoredFPFeatures() == HasFPFeatures);
155	while (NumStmts--)
156	Stmts.push_back(Elt: Record.readSubStmt());
157	S->setStmts(Stmts);
158	if (HasFPFeatures)
159	S->setStoredFPFeatures(
160	FPOptionsOverride::getFromOpaqueInt(I: Record.readInt()));
161	S->LBraceLoc = readSourceLocation();
162	S->RBraceLoc = readSourceLocation();
163	}
164
165	void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
166	VisitStmt(S);
167	Record.recordSwitchCaseID(SC: S, ID: Record.readInt());
168	S->setKeywordLoc(readSourceLocation());
169	S->setColonLoc(readSourceLocation());
170	}
171
172	void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
173	VisitSwitchCase(S);
174	bool CaseStmtIsGNURange = Record.readInt();
175	S->setLHS(Record.readSubExpr());
176	S->setSubStmt(Record.readSubStmt());
177	if (CaseStmtIsGNURange) {
178	S->setRHS(Record.readSubExpr());
179	S->setEllipsisLoc(readSourceLocation());
180	}
181	}
182
183	void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
184	VisitSwitchCase(S);
185	S->setSubStmt(Record.readSubStmt());
186	}
187
188	void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
189	VisitStmt(S);
190	bool IsSideEntry = Record.readInt();
191	auto *LD = readDeclAs<LabelDecl>();
192	LD->setStmt(S);
193	S->setDecl(LD);
194	S->setSubStmt(Record.readSubStmt());
195	S->setIdentLoc(readSourceLocation());
196	S->setSideEntry(IsSideEntry);
197	}
198
199	void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) {
200	VisitStmt(S);
201	// NumAttrs in AttributedStmt is set when creating an empty
202	// AttributedStmt in AttributedStmt::CreateEmpty, since it is needed
203	// to allocate the right amount of space for the trailing Attr *.
204	uint64_t NumAttrs = Record.readInt();
205	AttrVec Attrs;
206	Record.readAttributes(Attrs);
207	(void)NumAttrs;
208	assert(NumAttrs == S->AttributedStmtBits.NumAttrs);
209	assert(NumAttrs == Attrs.size());
210	std::copy(first: Attrs.begin(), last: Attrs.end(), result: S->getAttrArrayPtr());
211	S->SubStmt = Record.readSubStmt();
212	S->AttributedStmtBits.AttrLoc = readSourceLocation();
213	}
214
215	void ASTStmtReader::VisitIfStmt(IfStmt *S) {
216	VisitStmt(S);
217
218	CurrentUnpackingBits.emplace(args: Record.readInt());
219
220	bool HasElse = CurrentUnpackingBits->getNextBit();
221	bool HasVar = CurrentUnpackingBits->getNextBit();
222	bool HasInit = CurrentUnpackingBits->getNextBit();
223
224	S->setStatementKind(static_cast<IfStatementKind>(Record.readInt()));
225	S->setCond(Record.readSubExpr());
226	S->setThen(Record.readSubStmt());
227	if (HasElse)
228	S->setElse(Record.readSubStmt());
229	if (HasVar)
230	S->setConditionVariableDeclStmt(cast<DeclStmt>(Val: Record.readSubStmt()));
231	if (HasInit)
232	S->setInit(Record.readSubStmt());
233
234	S->setIfLoc(readSourceLocation());
235	S->setLParenLoc(readSourceLocation());
236	S->setRParenLoc(readSourceLocation());
237	if (HasElse)
238	S->setElseLoc(readSourceLocation());
239	}
240
241	void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
242	VisitStmt(S);
243
244	bool HasInit = Record.readInt();
245	bool HasVar = Record.readInt();
246	bool AllEnumCasesCovered = Record.readInt();
247	if (AllEnumCasesCovered)
248	S->setAllEnumCasesCovered();
249
250	S->setCond(Record.readSubExpr());
251	S->setBody(Record.readSubStmt());
252	if (HasInit)
253	S->setInit(Record.readSubStmt());
254	if (HasVar)
255	S->setConditionVariableDeclStmt(cast<DeclStmt>(Val: Record.readSubStmt()));
256
257	S->setSwitchLoc(readSourceLocation());
258	S->setLParenLoc(readSourceLocation());
259	S->setRParenLoc(readSourceLocation());
260
261	SwitchCase *PrevSC = nullptr;
262	for (auto E = Record.size(); Record.getIdx() != E; ) {
263	SwitchCase *SC = Record.getSwitchCaseWithID(ID: Record.readInt());
264	if (PrevSC)
265	PrevSC->setNextSwitchCase(SC);
266	else
267	S->setSwitchCaseList(SC);
268
269	PrevSC = SC;
270	}
271	}
272
273	void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
274	VisitStmt(S);
275
276	bool HasVar = Record.readInt();
277
278	S->setCond(Record.readSubExpr());
279	S->setBody(Record.readSubStmt());
280	if (HasVar)
281	S->setConditionVariableDeclStmt(cast<DeclStmt>(Val: Record.readSubStmt()));
282
283	S->setWhileLoc(readSourceLocation());
284	S->setLParenLoc(readSourceLocation());
285	S->setRParenLoc(readSourceLocation());
286	}
287
288	void ASTStmtReader::VisitDoStmt(DoStmt *S) {
289	VisitStmt(S);
290	S->setCond(Record.readSubExpr());
291	S->setBody(Record.readSubStmt());
292	S->setDoLoc(readSourceLocation());
293	S->setWhileLoc(readSourceLocation());
294	S->setRParenLoc(readSourceLocation());
295	}
296
297	void ASTStmtReader::VisitForStmt(ForStmt *S) {
298	VisitStmt(S);
299	S->setInit(Record.readSubStmt());
300	S->setCond(Record.readSubExpr());
301	S->setConditionVariableDeclStmt(cast_or_null<DeclStmt>(Val: Record.readSubStmt()));
302	S->setInc(Record.readSubExpr());
303	S->setBody(Record.readSubStmt());
304	S->setForLoc(readSourceLocation());
305	S->setLParenLoc(readSourceLocation());
306	S->setRParenLoc(readSourceLocation());
307	}
308
309	void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
310	VisitStmt(S);
311	S->setLabel(readDeclAs<LabelDecl>());
312	S->setGotoLoc(readSourceLocation());
313	S->setLabelLoc(readSourceLocation());
314	}
315
316	void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
317	VisitStmt(S);
318	S->setGotoLoc(readSourceLocation());
319	S->setStarLoc(readSourceLocation());
320	S->setTarget(Record.readSubExpr());
321	}
322
323	void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
324	VisitStmt(S);
325	S->setContinueLoc(readSourceLocation());
326	}
327
328	void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
329	VisitStmt(S);
330	S->setBreakLoc(readSourceLocation());
331	}
332
333	void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
334	VisitStmt(S);
335
336	bool HasNRVOCandidate = Record.readInt();
337
338	S->setRetValue(Record.readSubExpr());
339	if (HasNRVOCandidate)
340	S->setNRVOCandidate(readDeclAs<VarDecl>());
341
342	S->setReturnLoc(readSourceLocation());
343	}
344
345	void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
346	VisitStmt(S);
347	S->setStartLoc(readSourceLocation());
348	S->setEndLoc(readSourceLocation());
349
350	if (Record.size() - Record.getIdx() == 1) {
351	// Single declaration
352	S->setDeclGroup(DeclGroupRef(readDecl()));
353	} else {
354	SmallVector<Decl *, 16> Decls;
355	int N = Record.size() - Record.getIdx();
356	Decls.reserve(N);
357	for (int I = 0; I < N; ++I)
358	Decls.push_back(Elt: readDecl());
359	S->setDeclGroup(DeclGroupRef(DeclGroup::Create(C&: Record.getContext(),
360	Decls: Decls.data(),
361	NumDecls: Decls.size())));
362	}
363	}
364
365	void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
366	VisitStmt(S);
367	S->NumOutputs = Record.readInt();
368	S->NumInputs = Record.readInt();
369	S->NumClobbers = Record.readInt();
370	S->setAsmLoc(readSourceLocation());
371	S->setVolatile(Record.readInt());
372	S->setSimple(Record.readInt());
373	}
374
375	void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) {
376	VisitAsmStmt(S);
377	S->NumLabels = Record.readInt();
378	S->setRParenLoc(readSourceLocation());
379	S->setAsmStringExpr(cast_or_null<Expr>(Val: Record.readSubStmt()));
380
381	unsigned NumOutputs = S->getNumOutputs();
382	unsigned NumInputs = S->getNumInputs();
383	unsigned NumClobbers = S->getNumClobbers();
384	unsigned NumLabels = S->getNumLabels();
385
386	// Outputs and inputs
387	SmallVector<IdentifierInfo *, 16> Names;
388	SmallVector<Expr *, 16> Constraints;
389	SmallVector<Stmt*, 16> Exprs;
390	for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
391	Names.push_back(Elt: Record.readIdentifier());
392	Constraints.push_back(Elt: cast_or_null<Expr>(Val: Record.readSubStmt()));
393	Exprs.push_back(Elt: Record.readSubStmt());
394	}
395
396	// Constraints
397	SmallVector<Expr *, 16> Clobbers;
398	for (unsigned I = 0; I != NumClobbers; ++I)
399	Clobbers.push_back(Elt: cast_or_null<Expr>(Val: Record.readSubStmt()));
400
401	// Labels
402	for (unsigned I = 0, N = NumLabels; I != N; ++I) {
403	Names.push_back(Elt: Record.readIdentifier());
404	Exprs.push_back(Elt: Record.readSubStmt());
405	}
406
407	S->setOutputsAndInputsAndClobbers(C: Record.getContext(),
408	Names: Names.data(), Constraints: Constraints.data(),
409	Exprs: Exprs.data(), NumOutputs, NumInputs,
410	NumLabels,
411	Clobbers: Clobbers.data(), NumClobbers);
412	}
413
414	void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) {
415	VisitAsmStmt(S);
416	S->LBraceLoc = readSourceLocation();
417	S->EndLoc = readSourceLocation();
418	S->NumAsmToks = Record.readInt();
419	std::string AsmStr = readString();
420
421	// Read the tokens.
422	SmallVector<Token, 16> AsmToks;
423	AsmToks.reserve(N: S->NumAsmToks);
424	for (unsigned i = 0, e = S->NumAsmToks; i != e; ++i) {
425	AsmToks.push_back(Elt: Record.readToken());
426	}
427
428	// The calls to reserve() for the FooData vectors are mandatory to
429	// prevent dead StringRefs in the Foo vectors.
430
431	// Read the clobbers.
432	SmallVector<std::string, 16> ClobbersData;
433	SmallVector<StringRef, 16> Clobbers;
434	ClobbersData.reserve(N: S->NumClobbers);
435	Clobbers.reserve(N: S->NumClobbers);
436	for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) {
437	ClobbersData.push_back(Elt: readString());
438	Clobbers.push_back(Elt: ClobbersData.back());
439	}
440
441	// Read the operands.
442	unsigned NumOperands = S->NumOutputs + S->NumInputs;
443	SmallVector<Expr*, 16> Exprs;
444	SmallVector<std::string, 16> ConstraintsData;
445	SmallVector<StringRef, 16> Constraints;
446	Exprs.reserve(N: NumOperands);
447	ConstraintsData.reserve(N: NumOperands);
448	Constraints.reserve(N: NumOperands);
449	for (unsigned i = 0; i != NumOperands; ++i) {
450	Exprs.push_back(Elt: cast<Expr>(Val: Record.readSubStmt()));
451	ConstraintsData.push_back(Elt: readString());
452	Constraints.push_back(Elt: ConstraintsData.back());
453	}
454
455	S->initialize(C: Record.getContext(), AsmString: AsmStr, AsmToks,
456	Constraints, Exprs, Clobbers);
457	}
458
459	void ASTStmtReader::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
460	VisitStmt(S);
461	assert(Record.peekInt() == S->NumParams);
462	Record.skipInts(N: 1);
463	auto *StoredStmts = S->getStoredStmts();
464	for (unsigned i = 0;
465	i < CoroutineBodyStmt::SubStmt::FirstParamMove + S->NumParams; ++i)
466	StoredStmts[i] = Record.readSubStmt();
467	}
468
469	void ASTStmtReader::VisitCoreturnStmt(CoreturnStmt *S) {
470	VisitStmt(S);
471	S->CoreturnLoc = Record.readSourceLocation();
472	for (auto &SubStmt: S->SubStmts)
473	SubStmt = Record.readSubStmt();
474	S->IsImplicit = Record.readInt() != 0;
475	}
476
477	void ASTStmtReader::VisitCoawaitExpr(CoawaitExpr *E) {
478	VisitExpr(E);
479	E->KeywordLoc = readSourceLocation();
480	for (auto &SubExpr: E->SubExprs)
481	SubExpr = Record.readSubStmt();
482	E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Val: Record.readSubStmt());
483	E->setIsImplicit(Record.readInt() != 0);
484	}
485
486	void ASTStmtReader::VisitCoyieldExpr(CoyieldExpr *E) {
487	VisitExpr(E);
488	E->KeywordLoc = readSourceLocation();
489	for (auto &SubExpr: E->SubExprs)
490	SubExpr = Record.readSubStmt();
491	E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Val: Record.readSubStmt());
492	}
493
494	void ASTStmtReader::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) {
495	VisitExpr(E);
496	E->KeywordLoc = readSourceLocation();
497	for (auto &SubExpr: E->SubExprs)
498	SubExpr = Record.readSubStmt();
499	}
500
501	void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) {
502	VisitStmt(S);
503	Record.skipInts(N: 1);
504	S->setCapturedDecl(readDeclAs<CapturedDecl>());
505	S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record.readInt()));
506	S->setCapturedRecordDecl(readDeclAs<RecordDecl>());
507
508	// Capture inits
509	for (CapturedStmt::capture_init_iterator I = S->capture_init_begin(),
510	E = S->capture_init_end();
511	I != E; ++I)
512	*I = Record.readSubExpr();
513
514	// Body
515	S->setCapturedStmt(Record.readSubStmt());
516	S->getCapturedDecl()->setBody(S->getCapturedStmt());
517
518	// Captures
519	for (auto &I : S->captures()) {
520	I.VarAndKind.setPointer(readDeclAs<VarDecl>());
521	I.VarAndKind.setInt(
522	static_cast<CapturedStmt::VariableCaptureKind>(Record.readInt()));
523	I.Loc = readSourceLocation();
524	}
525	}
526
527	void ASTStmtReader::VisitSYCLKernelCallStmt(SYCLKernelCallStmt *S) {
528	VisitStmt(S);
529	S->setOriginalStmt(cast<CompoundStmt>(Val: Record.readSubStmt()));
530	S->setOutlinedFunctionDecl(readDeclAs<OutlinedFunctionDecl>());
531	}
532
533	void ASTStmtReader::VisitExpr(Expr *E) {
534	VisitStmt(E);
535	CurrentUnpackingBits.emplace(args: Record.readInt());
536	E->setDependence(static_cast<ExprDependence>(
537	CurrentUnpackingBits->getNextBits(/*Width=*/5)));
538	E->setValueKind(static_cast<ExprValueKind>(
539	CurrentUnpackingBits->getNextBits(/*Width=*/2)));
540	E->setObjectKind(static_cast<ExprObjectKind>(
541	CurrentUnpackingBits->getNextBits(/*Width=*/3)));
542
543	E->setType(Record.readType());
544	assert(Record.getIdx() == NumExprFields &&
545	"Incorrect expression field count");
546	}
547
548	void ASTStmtReader::VisitConstantExpr(ConstantExpr *E) {
549	VisitExpr(E);
550
551	auto StorageKind = static_cast<ConstantResultStorageKind>(Record.readInt());
552	assert(E->getResultStorageKind() == StorageKind && "Wrong ResultKind!");
553
554	E->ConstantExprBits.APValueKind = Record.readInt();
555	E->ConstantExprBits.IsUnsigned = Record.readInt();
556	E->ConstantExprBits.BitWidth = Record.readInt();
557	E->ConstantExprBits.HasCleanup = false; // Not serialized, see below.
558	E->ConstantExprBits.IsImmediateInvocation = Record.readInt();
559
560	switch (StorageKind) {
561	case ConstantResultStorageKind::None:
562	break;
563
564	case ConstantResultStorageKind::Int64:
565	E->Int64Result() = Record.readInt();
566	break;
567
568	case ConstantResultStorageKind::APValue:
569	E->APValueResult() = Record.readAPValue();
570	if (E->APValueResult().needsCleanup()) {
571	E->ConstantExprBits.HasCleanup = true;
572	Record.getContext().addDestruction(Ptr: &E->APValueResult());
573	}
574	break;
575	}
576
577	E->setSubExpr(Record.readSubExpr());
578	}
579
580	void ASTStmtReader::VisitOpenACCAsteriskSizeExpr(OpenACCAsteriskSizeExpr *E) {
581	VisitExpr(E);
582	E->setAsteriskLocation(readSourceLocation());
583	}
584
585	void ASTStmtReader::VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E) {
586	VisitExpr(E);
587
588	E->setLocation(readSourceLocation());
589	E->setLParenLocation(readSourceLocation());
590	E->setRParenLocation(readSourceLocation());
591
592	E->setTypeSourceInfo(Record.readTypeSourceInfo());
593	}
594
595	void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
596	VisitExpr(E);
597	bool HasFunctionName = Record.readInt();
598	E->PredefinedExprBits.HasFunctionName = HasFunctionName;
599	E->PredefinedExprBits.Kind = Record.readInt();
600	E->PredefinedExprBits.IsTransparent = Record.readInt();
601	E->setLocation(readSourceLocation());
602	if (HasFunctionName)
603	E->setFunctionName(cast<StringLiteral>(Val: Record.readSubExpr()));
604	}
605
606	void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
607	VisitExpr(E);
608
609	CurrentUnpackingBits.emplace(args: Record.readInt());
610	E->DeclRefExprBits.HadMultipleCandidates = CurrentUnpackingBits->getNextBit();
611	E->DeclRefExprBits.RefersToEnclosingVariableOrCapture =
612	CurrentUnpackingBits->getNextBit();
613	E->DeclRefExprBits.NonOdrUseReason =
614	CurrentUnpackingBits->getNextBits(/*Width=*/2);
615	E->DeclRefExprBits.IsImmediateEscalating = CurrentUnpackingBits->getNextBit();
616	E->DeclRefExprBits.HasFoundDecl = CurrentUnpackingBits->getNextBit();
617	E->DeclRefExprBits.HasQualifier = CurrentUnpackingBits->getNextBit();
618	E->DeclRefExprBits.HasTemplateKWAndArgsInfo =
619	CurrentUnpackingBits->getNextBit();
620	E->DeclRefExprBits.CapturedByCopyInLambdaWithExplicitObjectParameter = false;
621	unsigned NumTemplateArgs = 0;
622	if (E->hasTemplateKWAndArgsInfo())
623	NumTemplateArgs = Record.readInt();
624
625	if (E->hasQualifier())
626	new (E->getTrailingObjects<NestedNameSpecifierLoc>())
627	NestedNameSpecifierLoc(Record.readNestedNameSpecifierLoc());
628
629	if (E->hasFoundDecl())
630	*E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>();
631
632	if (E->hasTemplateKWAndArgsInfo())
633	ReadTemplateKWAndArgsInfo(
634	Args&: *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
635	ArgsLocArray: E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
636
637	E->D = readDeclAs<ValueDecl>();
638	E->setLocation(readSourceLocation());
639	E->DNLoc = Record.readDeclarationNameLoc(Name: E->getDecl()->getDeclName());
640	}
641
642	void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
643	VisitExpr(E);
644	E->setLocation(readSourceLocation());
645	E->setValue(C: Record.getContext(), Val: Record.readAPInt());
646	}
647
648	void ASTStmtReader::VisitFixedPointLiteral(FixedPointLiteral *E) {
649	VisitExpr(E);
650	E->setLocation(readSourceLocation());
651	E->setScale(Record.readInt());
652	E->setValue(C: Record.getContext(), Val: Record.readAPInt());
653	}
654
655	void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
656	VisitExpr(E);
657	E->setRawSemantics(
658	static_cast<llvm::APFloatBase::Semantics>(Record.readInt()));
659	E->setExact(Record.readInt());
660	E->setValue(C: Record.getContext(), Val: Record.readAPFloat(Sem: E->getSemantics()));
661	E->setLocation(readSourceLocation());
662	}
663
664	void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
665	VisitExpr(E);
666	E->setSubExpr(Record.readSubExpr());
667	}
668
669	void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
670	VisitExpr(E);
671
672	// NumConcatenated, Length and CharByteWidth are set by the empty
673	// ctor since they are needed to allocate storage for the trailing objects.
674	unsigned NumConcatenated = Record.readInt();
675	unsigned Length = Record.readInt();
676	unsigned CharByteWidth = Record.readInt();
677	assert((NumConcatenated == E->getNumConcatenated()) &&
678	"Wrong number of concatenated tokens!");
679	assert((Length == E->getLength()) && "Wrong Length!");
680	assert((CharByteWidth == E->getCharByteWidth()) && "Wrong character width!");
681	E->StringLiteralBits.Kind = Record.readInt();
682	E->StringLiteralBits.IsPascal = Record.readInt();
683
684	// The character width is originally computed via mapCharByteWidth.
685	// Check that the deserialized character width is consistant with the result
686	// of calling mapCharByteWidth.
687	assert((CharByteWidth ==
688	StringLiteral::mapCharByteWidth(Record.getContext().getTargetInfo(),
689	E->getKind())) &&
690	"Wrong character width!");
691
692	// Deserialize the trailing array of SourceLocation.
693	for (unsigned I = 0; I < NumConcatenated; ++I)
694	E->setStrTokenLoc(TokNum: I, L: readSourceLocation());
695
696	// Deserialize the trailing array of char holding the string data.
697	char *StrData = E->getStrDataAsChar();
698	for (unsigned I = 0; I < Length * CharByteWidth; ++I)
699	StrData[I] = Record.readInt();
700	}
701
702	void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
703	VisitExpr(E);
704	E->setValue(Record.readInt());
705	E->setLocation(readSourceLocation());
706	E->setKind(static_cast<CharacterLiteralKind>(Record.readInt()));
707	}
708
709	void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
710	VisitExpr(E);
711	E->setIsProducedByFoldExpansion(Record.readInt());
712	E->setLParen(readSourceLocation());
713	E->setRParen(readSourceLocation());
714	E->setSubExpr(Record.readSubExpr());
715	}
716
717	void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
718	VisitExpr(E);
719	unsigned NumExprs = Record.readInt();
720	assert((NumExprs == E->getNumExprs()) && "Wrong NumExprs!");
721	for (unsigned I = 0; I != NumExprs; ++I)
722	E->getTrailingObjects<Stmt *>()[I] = Record.readSubStmt();
723	E->LParenLoc = readSourceLocation();
724	E->RParenLoc = readSourceLocation();
725	}
726
727	void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
728	VisitExpr(E);
729	bool hasFP_Features = CurrentUnpackingBits->getNextBit();
730	assert(hasFP_Features == E->hasStoredFPFeatures());
731	E->setSubExpr(Record.readSubExpr());
732	E->setOpcode(
733	(UnaryOperator::Opcode)CurrentUnpackingBits->getNextBits(/*Width=*/5));
734	E->setOperatorLoc(readSourceLocation());
735	E->setCanOverflow(CurrentUnpackingBits->getNextBit());
736	if (hasFP_Features)
737	E->setStoredFPFeatures(
738	FPOptionsOverride::getFromOpaqueInt(I: Record.readInt()));
739	}
740
741	void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
742	VisitExpr(E);
743	assert(E->getNumComponents() == Record.peekInt());
744	Record.skipInts(N: 1);
745	assert(E->getNumExpressions() == Record.peekInt());
746	Record.skipInts(N: 1);
747	E->setOperatorLoc(readSourceLocation());
748	E->setRParenLoc(readSourceLocation());
749	E->setTypeSourceInfo(readTypeSourceInfo());
750	for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
751	auto Kind = static_cast<OffsetOfNode::Kind>(Record.readInt());
752	SourceLocation Start = readSourceLocation();
753	SourceLocation End = readSourceLocation();
754	switch (Kind) {
755	case OffsetOfNode::Array:
756	E->setComponent(Idx: I, ON: OffsetOfNode(Start, Record.readInt(), End));
757	break;
758
759	case OffsetOfNode::Field:
760	E->setComponent(
761	Idx: I, ON: OffsetOfNode(Start, readDeclAs<FieldDecl>(), End));
762	break;
763
764	case OffsetOfNode::Identifier:
765	E->setComponent(
766	Idx: I,
767	ON: OffsetOfNode(Start, Record.readIdentifier(), End));
768	break;
769
770	case OffsetOfNode::Base: {
771	auto *Base = new (Record.getContext()) CXXBaseSpecifier();
772	*Base = Record.readCXXBaseSpecifier();
773	E->setComponent(Idx: I, ON: OffsetOfNode(Base));
774	break;
775	}
776	}
777	}
778
779	for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
780	E->setIndexExpr(Idx: I, E: Record.readSubExpr());
781	}
782
783	void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
784	VisitExpr(E);
785	E->setKind(static_cast<UnaryExprOrTypeTrait>(Record.readInt()));
786	if (Record.peekInt() == 0) {
787	E->setArgument(Record.readSubExpr());
788	Record.skipInts(N: 1);
789	} else {
790	E->setArgument(readTypeSourceInfo());
791	}
792	E->setOperatorLoc(readSourceLocation());
793	E->setRParenLoc(readSourceLocation());
794	}
795
796	static ConstraintSatisfaction
797	readConstraintSatisfaction(ASTRecordReader &Record) {
798	ConstraintSatisfaction Satisfaction;
799	Satisfaction.IsSatisfied = Record.readInt();
800	Satisfaction.ContainsErrors = Record.readInt();
801	const ASTContext &C = Record.getContext();
802	if (!Satisfaction.IsSatisfied) {
803	unsigned NumDetailRecords = Record.readInt();
804	for (unsigned i = 0; i != NumDetailRecords; ++i) {
805	if (/* IsDiagnostic */Record.readInt()) {
806	SourceLocation DiagLocation = Record.readSourceLocation();
807	StringRef DiagMessage = C.backupStr(S: Record.readString());
808
809	Satisfaction.Details.emplace_back(
810	Args: new (C) ConstraintSatisfaction::SubstitutionDiagnostic(
811	DiagLocation, DiagMessage));
812	} else
813	Satisfaction.Details.emplace_back(Args: Record.readExpr());
814	}
815	}
816	return Satisfaction;
817	}
818
819	void ASTStmtReader::VisitConceptSpecializationExpr(
820	ConceptSpecializationExpr *E) {
821	VisitExpr(E);
822	E->SpecDecl = Record.readDeclAs<ImplicitConceptSpecializationDecl>();
823	if (Record.readBool())
824	E->ConceptRef = Record.readConceptReference();
825	E->Satisfaction = E->isValueDependent() ? nullptr :
826	ASTConstraintSatisfaction::Create(C: Record.getContext(),
827	Satisfaction: readConstraintSatisfaction(Record));
828	}
829
830	static concepts::Requirement::SubstitutionDiagnostic *
831	readSubstitutionDiagnostic(ASTRecordReader &Record) {
832	const ASTContext &C = Record.getContext();
833	StringRef SubstitutedEntity = C.backupStr(S: Record.readString());
834	SourceLocation DiagLoc = Record.readSourceLocation();
835	StringRef DiagMessage = C.backupStr(S: Record.readString());
836
837	return new (Record.getContext())
838	concepts::Requirement::SubstitutionDiagnostic{.SubstitutedEntity: SubstitutedEntity, .DiagLoc: DiagLoc,
839	.DiagMessage: DiagMessage};
840	}
841
842	void ASTStmtReader::VisitRequiresExpr(RequiresExpr *E) {
843	VisitExpr(E);
844	unsigned NumLocalParameters = Record.readInt();
845	unsigned NumRequirements = Record.readInt();
846	E->RequiresExprBits.RequiresKWLoc = Record.readSourceLocation();
847	E->RequiresExprBits.IsSatisfied = Record.readInt();
848	E->Body = Record.readDeclAs<RequiresExprBodyDecl>();
849	llvm::SmallVector<ParmVarDecl *, 4> LocalParameters;
850	for (unsigned i = 0; i < NumLocalParameters; ++i)
851	LocalParameters.push_back(Elt: cast<ParmVarDecl>(Val: Record.readDecl()));
852	std::copy(LocalParameters.begin(), LocalParameters.end(),
853	E->getTrailingObjects<ParmVarDecl *>());
854	llvm::SmallVector<concepts::Requirement *, 4> Requirements;
855	for (unsigned i = 0; i < NumRequirements; ++i) {
856	auto RK =
857	static_cast<concepts::Requirement::RequirementKind>(Record.readInt());
858	concepts::Requirement *R = nullptr;
859	switch (RK) {
860	case concepts::Requirement::RK_Type: {
861	auto Status =
862	static_cast<concepts::TypeRequirement::SatisfactionStatus>(
863	Record.readInt());
864	if (Status == concepts::TypeRequirement::SS_SubstitutionFailure)
865	R = new (Record.getContext())
866	concepts::TypeRequirement(readSubstitutionDiagnostic(Record));
867	else
868	R = new (Record.getContext())
869	concepts::TypeRequirement(Record.readTypeSourceInfo());
870	} break;
871	case concepts::Requirement::RK_Simple:
872	case concepts::Requirement::RK_Compound: {
873	auto Status =
874	static_cast<concepts::ExprRequirement::SatisfactionStatus>(
875	Record.readInt());
876	llvm::PointerUnion<concepts::Requirement::SubstitutionDiagnostic *,
877	Expr *> E;
878	if (Status == concepts::ExprRequirement::SS_ExprSubstitutionFailure) {
879	E = readSubstitutionDiagnostic(Record);
880	} else
881	E = Record.readExpr();
882
883	std::optional<concepts::ExprRequirement::ReturnTypeRequirement> Req;
884	ConceptSpecializationExpr *SubstitutedConstraintExpr = nullptr;
885	SourceLocation NoexceptLoc;
886	if (RK == concepts::Requirement::RK_Simple) {
887	Req.emplace();
888	} else {
889	NoexceptLoc = Record.readSourceLocation();
890	switch (/* returnTypeRequirementKind */Record.readInt()) {
891	case 0:
892	// No return type requirement.
893	Req.emplace();
894	break;
895	case 1: {
896	// type-constraint
897	TemplateParameterList *TPL = Record.readTemplateParameterList();
898	if (Status >=
899	concepts::ExprRequirement::SS_ConstraintsNotSatisfied)
900	SubstitutedConstraintExpr =
901	cast<ConceptSpecializationExpr>(Val: Record.readExpr());
902	Req.emplace(args&: TPL);
903	} break;
904	case 2:
905	// Substitution failure
906	Req.emplace(args: readSubstitutionDiagnostic(Record));
907	break;
908	}
909	}
910	if (Expr *Ex = E.dyn_cast<Expr *>())
911	R = new (Record.getContext()) concepts::ExprRequirement(
912	Ex, RK == concepts::Requirement::RK_Simple, NoexceptLoc,
913	std::move(*Req), Status, SubstitutedConstraintExpr);
914	else
915	R = new (Record.getContext()) concepts::ExprRequirement(
916	cast<concepts::Requirement::SubstitutionDiagnostic *>(Val&: E),
917	RK == concepts::Requirement::RK_Simple, NoexceptLoc,
918	std::move(*Req));
919	} break;
920	case concepts::Requirement::RK_Nested: {
921	ASTContext &C = Record.getContext();
922	bool HasInvalidConstraint = Record.readInt();
923	if (HasInvalidConstraint) {
924	StringRef InvalidConstraint = C.backupStr(S: Record.readString());
925	R = new (C) concepts::NestedRequirement(
926	Record.getContext(), InvalidConstraint,
927	readConstraintSatisfaction(Record));
928	break;
929	}
930	Expr *E = Record.readExpr();
931	if (E->isInstantiationDependent())
932	R = new (C) concepts::NestedRequirement(E);
933	else
934	R = new (C) concepts::NestedRequirement(
935	C, E, readConstraintSatisfaction(Record));
936	} break;
937	}
938	if (!R)
939	continue;
940	Requirements.push_back(Elt: R);
941	}
942	std::copy(Requirements.begin(), Requirements.end(),
943	E->getTrailingObjects<concepts::Requirement *>());
944	E->LParenLoc = Record.readSourceLocation();
945	E->RParenLoc = Record.readSourceLocation();
946	E->RBraceLoc = Record.readSourceLocation();
947	}
948
949	void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
950	VisitExpr(E);
951	E->setLHS(Record.readSubExpr());
952	E->setRHS(Record.readSubExpr());
953	E->setRBracketLoc(readSourceLocation());
954	}
955
956	void ASTStmtReader::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E) {
957	VisitExpr(E);
958	E->setBase(Record.readSubExpr());
959	E->setRowIdx(Record.readSubExpr());
960	E->setColumnIdx(Record.readSubExpr());
961	E->setRBracketLoc(readSourceLocation());
962	}
963
964	void ASTStmtReader::VisitArraySectionExpr(ArraySectionExpr *E) {
965	VisitExpr(E);
966	E->ASType = Record.readEnum<ArraySectionExpr::ArraySectionType>();
967
968	E->setBase(Record.readSubExpr());
969	E->setLowerBound(Record.readSubExpr());
970	E->setLength(Record.readSubExpr());
971
972	if (E->isOMPArraySection())
973	E->setStride(Record.readSubExpr());
974
975	E->setColonLocFirst(readSourceLocation());
976
977	if (E->isOMPArraySection())
978	E->setColonLocSecond(readSourceLocation());
979
980	E->setRBracketLoc(readSourceLocation());
981	}
982
983	void ASTStmtReader::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
984	VisitExpr(E);
985	unsigned NumDims = Record.readInt();
986	E->setBase(Record.readSubExpr());
987	SmallVector<Expr *, 4> Dims(NumDims);
988	for (unsigned I = 0; I < NumDims; ++I)
989	Dims[I] = Record.readSubExpr();
990	E->setDimensions(Dims);
991	SmallVector<SourceRange, 4> SRs(NumDims);
992	for (unsigned I = 0; I < NumDims; ++I)
993	SRs[I] = readSourceRange();
994	E->setBracketsRanges(SRs);
995	E->setLParenLoc(readSourceLocation());
996	E->setRParenLoc(readSourceLocation());
997	}
998
999	void ASTStmtReader::VisitOMPIteratorExpr(OMPIteratorExpr *E) {
1000	VisitExpr(E);
1001	unsigned NumIters = Record.readInt();
1002	E->setIteratorKwLoc(readSourceLocation());
1003	E->setLParenLoc(readSourceLocation());
1004	E->setRParenLoc(readSourceLocation());
1005	for (unsigned I = 0; I < NumIters; ++I) {
1006	E->setIteratorDeclaration(I, D: Record.readDeclRef());
1007	E->setAssignmentLoc(I, Loc: readSourceLocation());
1008	Expr *Begin = Record.readSubExpr();
1009	Expr *End = Record.readSubExpr();
1010	Expr *Step = Record.readSubExpr();
1011	SourceLocation ColonLoc = readSourceLocation();
1012	SourceLocation SecColonLoc;
1013	if (Step)
1014	SecColonLoc = readSourceLocation();
1015	E->setIteratorRange(I, Begin, ColonLoc, End, SecondColonLoc: SecColonLoc, Step);
1016	// Deserialize helpers
1017	OMPIteratorHelperData HD;
1018	HD.CounterVD = cast_or_null<VarDecl>(Val: Record.readDeclRef());
1019	HD.Upper = Record.readSubExpr();
1020	HD.Update = Record.readSubExpr();
1021	HD.CounterUpdate = Record.readSubExpr();
1022	E->setHelper(I, D: HD);
1023	}
1024	}
1025
1026	void ASTStmtReader::VisitCallExpr(CallExpr *E) {
1027	VisitExpr(E);
1028
1029	unsigned NumArgs = Record.readInt();
1030	CurrentUnpackingBits.emplace(args: Record.readInt());
1031	E->setADLCallKind(
1032	static_cast<CallExpr::ADLCallKind>(CurrentUnpackingBits->getNextBit()));
1033	bool HasFPFeatures = CurrentUnpackingBits->getNextBit();
1034	E->setCoroElideSafe(CurrentUnpackingBits->getNextBit());
1035	E->setUsesMemberSyntax(CurrentUnpackingBits->getNextBit());
1036	assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
1037	E->setRParenLoc(readSourceLocation());
1038	E->setCallee(Record.readSubExpr());
1039	for (unsigned I = 0; I != NumArgs; ++I)
1040	E->setArg(Arg: I, ArgExpr: Record.readSubExpr());
1041
1042	if (HasFPFeatures)
1043	E->setStoredFPFeatures(
1044	FPOptionsOverride::getFromOpaqueInt(I: Record.readInt()));
1045
1046	if (E->getStmtClass() == Stmt::CallExprClass)
1047	E->updateTrailingSourceLoc();
1048	}
1049
1050	void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1051	VisitCallExpr(E);
1052	}
1053
1054	void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
1055	VisitExpr(E);
1056
1057	CurrentUnpackingBits.emplace(args: Record.readInt());
1058	bool HasQualifier = CurrentUnpackingBits->getNextBit();
1059	bool HasFoundDecl = CurrentUnpackingBits->getNextBit();
1060	bool HasTemplateInfo = CurrentUnpackingBits->getNextBit();
1061	unsigned NumTemplateArgs = Record.readInt();
1062
1063	E->Base = Record.readSubExpr();
1064	E->MemberDecl = Record.readDeclAs<ValueDecl>();
1065	E->MemberDNLoc = Record.readDeclarationNameLoc(Name: E->MemberDecl->getDeclName());
1066	E->MemberLoc = Record.readSourceLocation();
1067	E->MemberExprBits.IsArrow = CurrentUnpackingBits->getNextBit();
1068	E->MemberExprBits.HasQualifier = HasQualifier;
1069	E->MemberExprBits.HasFoundDecl = HasFoundDecl;
1070	E->MemberExprBits.HasTemplateKWAndArgsInfo = HasTemplateInfo;
1071	E->MemberExprBits.HadMultipleCandidates = CurrentUnpackingBits->getNextBit();
1072	E->MemberExprBits.NonOdrUseReason =
1073	CurrentUnpackingBits->getNextBits(/*Width=*/2);
1074	E->MemberExprBits.OperatorLoc = Record.readSourceLocation();
1075
1076	if (HasQualifier)
1077	new (E->getTrailingObjects<NestedNameSpecifierLoc>())
1078	NestedNameSpecifierLoc(Record.readNestedNameSpecifierLoc());
1079
1080	if (HasFoundDecl) {
1081	auto *FoundD = Record.readDeclAs<NamedDecl>();
1082	auto AS = (AccessSpecifier)CurrentUnpackingBits->getNextBits(/*Width=*/2);
1083	*E->getTrailingObjects<DeclAccessPair>() = DeclAccessPair::make(D: FoundD, AS);
1084	}
1085
1086	if (HasTemplateInfo)
1087	ReadTemplateKWAndArgsInfo(
1088	Args&: *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1089	ArgsLocArray: E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
1090	}
1091
1092	void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
1093	VisitExpr(E);
1094	E->setBase(Record.readSubExpr());
1095	E->setIsaMemberLoc(readSourceLocation());
1096	E->setOpLoc(readSourceLocation());
1097	E->setArrow(Record.readInt());
1098	}
1099
1100	void ASTStmtReader::
1101	VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
1102	VisitExpr(E);
1103	E->Operand = Record.readSubExpr();
1104	E->setShouldCopy(Record.readInt());
1105	}
1106
1107	void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
1108	VisitExplicitCastExpr(E);
1109	E->LParenLoc = readSourceLocation();
1110	E->BridgeKeywordLoc = readSourceLocation();
1111	E->Kind = Record.readInt();
1112	}
1113
1114	void ASTStmtReader::VisitCastExpr(CastExpr *E) {
1115	VisitExpr(E);
1116	unsigned NumBaseSpecs = Record.readInt();
1117	assert(NumBaseSpecs == E->path_size());
1118
1119	CurrentUnpackingBits.emplace(args: Record.readInt());
1120	E->setCastKind((CastKind)CurrentUnpackingBits->getNextBits(/*Width=*/7));
1121	unsigned HasFPFeatures = CurrentUnpackingBits->getNextBit();
1122	assert(E->hasStoredFPFeatures() == HasFPFeatures);
1123
1124	E->setSubExpr(Record.readSubExpr());
1125
1126	CastExpr::path_iterator BaseI = E->path_begin();
1127	while (NumBaseSpecs--) {
1128	auto *BaseSpec = new (Record.getContext()) CXXBaseSpecifier;
1129	*BaseSpec = Record.readCXXBaseSpecifier();
1130	*BaseI++ = BaseSpec;
1131	}
1132	if (HasFPFeatures)
1133	*E->getTrailingFPFeatures() =
1134	FPOptionsOverride::getFromOpaqueInt(I: Record.readInt());
1135	}
1136
1137	void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
1138	VisitExpr(E);
1139	CurrentUnpackingBits.emplace(args: Record.readInt());
1140	E->setOpcode(
1141	(BinaryOperator::Opcode)CurrentUnpackingBits->getNextBits(/*Width=*/6));
1142	bool hasFP_Features = CurrentUnpackingBits->getNextBit();
1143	E->setHasStoredFPFeatures(hasFP_Features);
1144	E->setExcludedOverflowPattern(CurrentUnpackingBits->getNextBit());
1145	E->setLHS(Record.readSubExpr());
1146	E->setRHS(Record.readSubExpr());
1147	E->setOperatorLoc(readSourceLocation());
1148	if (hasFP_Features)
1149	E->setStoredFPFeatures(
1150	FPOptionsOverride::getFromOpaqueInt(I: Record.readInt()));
1151	}
1152
1153	void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
1154	VisitBinaryOperator(E);
1155	E->setComputationLHSType(Record.readType());
1156	E->setComputationResultType(Record.readType());
1157	}
1158
1159	void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
1160	VisitExpr(E);
1161	E->SubExprs[ConditionalOperator::COND] = Record.readSubExpr();
1162	E->SubExprs[ConditionalOperator::LHS] = Record.readSubExpr();
1163	E->SubExprs[ConditionalOperator::RHS] = Record.readSubExpr();
1164	E->QuestionLoc = readSourceLocation();
1165	E->ColonLoc = readSourceLocation();
1166	}
1167
1168	void
1169	ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
1170	VisitExpr(E);
1171	E->OpaqueValue = cast<OpaqueValueExpr>(Val: Record.readSubExpr());
1172	E->SubExprs[BinaryConditionalOperator::COMMON] = Record.readSubExpr();
1173	E->SubExprs[BinaryConditionalOperator::COND] = Record.readSubExpr();
1174	E->SubExprs[BinaryConditionalOperator::LHS] = Record.readSubExpr();
1175	E->SubExprs[BinaryConditionalOperator::RHS] = Record.readSubExpr();
1176	E->QuestionLoc = readSourceLocation();
1177	E->ColonLoc = readSourceLocation();
1178	}
1179
1180	void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
1181	VisitCastExpr(E);
1182	E->setIsPartOfExplicitCast(CurrentUnpackingBits->getNextBit());
1183	}
1184
1185	void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
1186	VisitCastExpr(E);
1187	E->setTypeInfoAsWritten(readTypeSourceInfo());
1188	}
1189
1190	void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
1191	VisitExplicitCastExpr(E);
1192	E->setLParenLoc(readSourceLocation());
1193	E->setRParenLoc(readSourceLocation());
1194	}
1195
1196	void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
1197	VisitExpr(E);
1198	E->setLParenLoc(readSourceLocation());
1199	E->setTypeSourceInfo(readTypeSourceInfo());
1200	E->setInitializer(Record.readSubExpr());
1201	E->setFileScope(Record.readInt());
1202	}
1203
1204	void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
1205	VisitExpr(E);
1206	E->setBase(Record.readSubExpr());
1207	E->setAccessor(Record.readIdentifier());
1208	E->setAccessorLoc(readSourceLocation());
1209	}
1210
1211	void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
1212	VisitExpr(E);
1213	if (auto *SyntForm = cast_or_null<InitListExpr>(Val: Record.readSubStmt()))
1214	E->setSyntacticForm(SyntForm);
1215	E->setLBraceLoc(readSourceLocation());
1216	E->setRBraceLoc(readSourceLocation());
1217	bool isArrayFiller = Record.readInt();
1218	Expr *filler = nullptr;
1219	if (isArrayFiller) {
1220	filler = Record.readSubExpr();
1221	E->ArrayFillerOrUnionFieldInit = filler;
1222	} else
1223	E->ArrayFillerOrUnionFieldInit = readDeclAs<FieldDecl>();
1224	E->sawArrayRangeDesignator(ARD: Record.readInt());
1225	unsigned NumInits = Record.readInt();
1226	E->reserveInits(C: Record.getContext(), NumInits);
1227	if (isArrayFiller) {
1228	for (unsigned I = 0; I != NumInits; ++I) {
1229	Expr *init = Record.readSubExpr();
1230	E->updateInit(C: Record.getContext(), Init: I, expr: init ? init : filler);
1231	}
1232	} else {
1233	for (unsigned I = 0; I != NumInits; ++I)
1234	E->updateInit(C: Record.getContext(), Init: I, expr: Record.readSubExpr());
1235	}
1236	}
1237
1238	void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
1239	using Designator = DesignatedInitExpr::Designator;
1240
1241	VisitExpr(E);
1242	unsigned NumSubExprs = Record.readInt();
1243	assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
1244	for (unsigned I = 0; I != NumSubExprs; ++I)
1245	E->setSubExpr(Idx: I, E: Record.readSubExpr());
1246	E->setEqualOrColonLoc(readSourceLocation());
1247	E->setGNUSyntax(Record.readInt());
1248
1249	SmallVector<Designator, 4> Designators;
1250	while (Record.getIdx() < Record.size()) {
1251	switch ((DesignatorTypes)Record.readInt()) {
1252	case DESIG_FIELD_DECL: {
1253	auto *Field = readDeclAs<FieldDecl>();
1254	SourceLocation DotLoc = readSourceLocation();
1255	SourceLocation FieldLoc = readSourceLocation();
1256	Designators.push_back(Elt: Designator::CreateFieldDesignator(
1257	FieldName: Field->getIdentifier(), DotLoc, FieldLoc));
1258	Designators.back().setFieldDecl(Field);
1259	break;
1260	}
1261
1262	case DESIG_FIELD_NAME: {
1263	const IdentifierInfo *Name = Record.readIdentifier();
1264	SourceLocation DotLoc = readSourceLocation();
1265	SourceLocation FieldLoc = readSourceLocation();
1266	Designators.push_back(Elt: Designator::CreateFieldDesignator(FieldName: Name, DotLoc,
1267	FieldLoc));
1268	break;
1269	}
1270
1271	case DESIG_ARRAY: {
1272	unsigned Index = Record.readInt();
1273	SourceLocation LBracketLoc = readSourceLocation();
1274	SourceLocation RBracketLoc = readSourceLocation();
1275	Designators.push_back(Elt: Designator::CreateArrayDesignator(Index,
1276	LBracketLoc,
1277	RBracketLoc));
1278	break;
1279	}
1280
1281	case DESIG_ARRAY_RANGE: {
1282	unsigned Index = Record.readInt();
1283	SourceLocation LBracketLoc = readSourceLocation();
1284	SourceLocation EllipsisLoc = readSourceLocation();
1285	SourceLocation RBracketLoc = readSourceLocation();
1286	Designators.push_back(Elt: Designator::CreateArrayRangeDesignator(
1287	Index, LBracketLoc, EllipsisLoc, RBracketLoc));
1288	break;
1289	}
1290	}
1291	}
1292	E->setDesignators(C: Record.getContext(),
1293	Desigs: Designators.data(), NumDesigs: Designators.size());
1294	}
1295
1296	void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
1297	VisitExpr(E);
1298	E->setBase(Record.readSubExpr());
1299	E->setUpdater(Record.readSubExpr());
1300	}
1301
1302	void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) {
1303	VisitExpr(E);
1304	}
1305
1306	void ASTStmtReader::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
1307	VisitExpr(E);
1308	E->SubExprs[0] = Record.readSubExpr();
1309	E->SubExprs[1] = Record.readSubExpr();
1310	}
1311
1312	void ASTStmtReader::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
1313	VisitExpr(E);
1314	}
1315
1316	void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
1317	VisitExpr(E);
1318	}
1319
1320	void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
1321	VisitExpr(E);
1322	E->setSubExpr(Record.readSubExpr());
1323	E->setWrittenTypeInfo(readTypeSourceInfo());
1324	E->setBuiltinLoc(readSourceLocation());
1325	E->setRParenLoc(readSourceLocation());
1326	E->setIsMicrosoftABI(Record.readInt());
1327	}
1328
1329	void ASTStmtReader::VisitSourceLocExpr(SourceLocExpr *E) {
1330	VisitExpr(E);
1331	E->ParentContext = readDeclAs<DeclContext>();
1332	E->BuiltinLoc = readSourceLocation();
1333	E->RParenLoc = readSourceLocation();
1334	E->SourceLocExprBits.Kind = Record.readInt();
1335	}
1336
1337	void ASTStmtReader::VisitEmbedExpr(EmbedExpr *E) {
1338	VisitExpr(E);
1339	E->EmbedKeywordLoc = readSourceLocation();
1340	EmbedDataStorage *Data = new (Record.getContext()) EmbedDataStorage;
1341	Data->BinaryData = cast<StringLiteral>(Val: Record.readSubStmt());
1342	E->Data = Data;
1343	E->Begin = Record.readInt();
1344	E->NumOfElements = Record.readInt();
1345	}
1346
1347	void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
1348	VisitExpr(E);
1349	E->setAmpAmpLoc(readSourceLocation());
1350	E->setLabelLoc(readSourceLocation());
1351	E->setLabel(readDeclAs<LabelDecl>());
1352	}
1353
1354	void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
1355	VisitExpr(E);
1356	E->setLParenLoc(readSourceLocation());
1357	E->setRParenLoc(readSourceLocation());
1358	E->setSubStmt(cast_or_null<CompoundStmt>(Val: Record.readSubStmt()));
1359	E->StmtExprBits.TemplateDepth = Record.readInt();
1360	}
1361
1362	void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
1363	VisitExpr(E);
1364	E->setCond(Record.readSubExpr());
1365	E->setLHS(Record.readSubExpr());
1366	E->setRHS(Record.readSubExpr());
1367	E->setBuiltinLoc(readSourceLocation());
1368	E->setRParenLoc(readSourceLocation());
1369	E->setIsConditionTrue(Record.readInt());
1370	}
1371
1372	void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
1373	VisitExpr(E);
1374	E->setTokenLocation(readSourceLocation());
1375	}
1376
1377	void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
1378	VisitExpr(E);
1379	SmallVector<Expr *, 16> Exprs;
1380	unsigned NumExprs = Record.readInt();
1381	while (NumExprs--)
1382	Exprs.push_back(Elt: Record.readSubExpr());
1383	E->setExprs(C: Record.getContext(), Exprs);
1384	E->setBuiltinLoc(readSourceLocation());
1385	E->setRParenLoc(readSourceLocation());
1386	}
1387
1388	void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) {
1389	VisitExpr(E);
1390	bool HasFPFeatures = CurrentUnpackingBits->getNextBit();
1391	assert(HasFPFeatures == E->hasStoredFPFeatures());
1392	E->BuiltinLoc = readSourceLocation();
1393	E->RParenLoc = readSourceLocation();
1394	E->TInfo = readTypeSourceInfo();
1395	E->SrcExpr = Record.readSubExpr();
1396	if (HasFPFeatures)
1397	E->setStoredFPFeatures(
1398	FPOptionsOverride::getFromOpaqueInt(I: Record.readInt()));
1399	}
1400
1401	void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
1402	VisitExpr(E);
1403	E->setBlockDecl(readDeclAs<BlockDecl>());
1404	}
1405
1406	void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
1407	VisitExpr(E);
1408
1409	unsigned NumAssocs = Record.readInt();
1410	assert(NumAssocs == E->getNumAssocs() && "Wrong NumAssocs!");
1411	E->IsExprPredicate = Record.readInt();
1412	E->ResultIndex = Record.readInt();
1413	E->GenericSelectionExprBits.GenericLoc = readSourceLocation();
1414	E->DefaultLoc = readSourceLocation();
1415	E->RParenLoc = readSourceLocation();
1416
1417	Stmt **Stmts = E->getTrailingObjects<Stmt *>();
1418	// Add 1 to account for the controlling expression which is the first
1419	// expression in the trailing array of Stmt *. This is not needed for
1420	// the trailing array of TypeSourceInfo *.
1421	for (unsigned I = 0, N = NumAssocs + 1; I < N; ++I)
1422	Stmts[I] = Record.readSubExpr();
1423
1424	TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>();
1425	for (unsigned I = 0, N = NumAssocs; I < N; ++I)
1426	TSIs[I] = readTypeSourceInfo();
1427	}
1428
1429	void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
1430	VisitExpr(E);
1431	unsigned numSemanticExprs = Record.readInt();
1432	assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs);
1433	E->PseudoObjectExprBits.ResultIndex = Record.readInt();
1434
1435	// Read the syntactic expression.
1436	E->getTrailingObjects()[0] = Record.readSubExpr();
1437
1438	// Read all the semantic expressions.
1439	for (unsigned i = 0; i != numSemanticExprs; ++i) {
1440	Expr *subExpr = Record.readSubExpr();
1441	E->getTrailingObjects()[i + 1] = subExpr;
1442	}
1443	}
1444
1445	void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {
1446	VisitExpr(E);
1447	E->Op = AtomicExpr::AtomicOp(Record.readInt());
1448	E->NumSubExprs = AtomicExpr::getNumSubExprs(Op: E->Op);
1449	for (unsigned I = 0; I != E->NumSubExprs; ++I)
1450	E->SubExprs[I] = Record.readSubExpr();
1451	E->BuiltinLoc = readSourceLocation();
1452	E->RParenLoc = readSourceLocation();
1453	}
1454
1455	//===----------------------------------------------------------------------===//
1456	// Objective-C Expressions and Statements
1457
1458	void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
1459	VisitExpr(E);
1460	E->setString(cast<StringLiteral>(Val: Record.readSubStmt()));
1461	E->setAtLoc(readSourceLocation());
1462	}
1463
1464	void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
1465	VisitExpr(E);
1466	// could be one of several IntegerLiteral, FloatLiteral, etc.
1467	E->SubExpr = Record.readSubStmt();
1468	E->BoxingMethod = readDeclAs<ObjCMethodDecl>();
1469	E->Range = readSourceRange();
1470	}
1471
1472	void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
1473	VisitExpr(E);
1474	unsigned NumElements = Record.readInt();
1475	assert(NumElements == E->getNumElements() && "Wrong number of elements");
1476	Expr **Elements = E->getElements();
1477	for (unsigned I = 0, N = NumElements; I != N; ++I)
1478	Elements[I] = Record.readSubExpr();
1479	E->ArrayWithObjectsMethod = readDeclAs<ObjCMethodDecl>();
1480	E->Range = readSourceRange();
1481	}
1482
1483	void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
1484	VisitExpr(E);
1485	unsigned NumElements = Record.readInt();
1486	assert(NumElements == E->getNumElements() && "Wrong number of elements");
1487	bool HasPackExpansions = Record.readInt();
1488	assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch");
1489	auto *KeyValues =
1490	E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>();
1491	auto *Expansions =
1492	E->getTrailingObjects<ObjCDictionaryLiteral::ExpansionData>();
1493	for (unsigned I = 0; I != NumElements; ++I) {
1494	KeyValues[I].Key = Record.readSubExpr();
1495	KeyValues[I].Value = Record.readSubExpr();
1496	if (HasPackExpansions) {
1497	Expansions[I].EllipsisLoc = readSourceLocation();
1498	Expansions[I].NumExpansionsPlusOne = Record.readInt();
1499	}
1500	}
1501	E->DictWithObjectsMethod = readDeclAs<ObjCMethodDecl>();
1502	E->Range = readSourceRange();
1503	}
1504
1505	void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
1506	VisitExpr(E);
1507	E->setEncodedTypeSourceInfo(readTypeSourceInfo());
1508	E->setAtLoc(readSourceLocation());
1509	E->setRParenLoc(readSourceLocation());
1510	}
1511
1512	void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
1513	VisitExpr(E);
1514	E->setSelector(Record.readSelector());
1515	E->setAtLoc(readSourceLocation());
1516	E->setRParenLoc(readSourceLocation());
1517	}
1518
1519	void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
1520	VisitExpr(E);
1521	E->setProtocol(readDeclAs<ObjCProtocolDecl>());
1522	E->setAtLoc(readSourceLocation());
1523	E->ProtoLoc = readSourceLocation();
1524	E->setRParenLoc(readSourceLocation());
1525	}
1526
1527	void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
1528	VisitExpr(E);
1529	E->setDecl(readDeclAs<ObjCIvarDecl>());
1530	E->setLocation(readSourceLocation());
1531	E->setOpLoc(readSourceLocation());
1532	E->setBase(Record.readSubExpr());
1533	E->setIsArrow(Record.readInt());
1534	E->setIsFreeIvar(Record.readInt());
1535	}
1536
1537	void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
1538	VisitExpr(E);
1539	unsigned MethodRefFlags = Record.readInt();
1540	bool Implicit = Record.readInt() != 0;
1541	if (Implicit) {
1542	auto *Getter = readDeclAs<ObjCMethodDecl>();
1543	auto *Setter = readDeclAs<ObjCMethodDecl>();
1544	E->setImplicitProperty(Getter, Setter, methRefFlags: MethodRefFlags);
1545	} else {
1546	E->setExplicitProperty(D: readDeclAs<ObjCPropertyDecl>(), methRefFlags: MethodRefFlags);
1547	}
1548	E->setLocation(readSourceLocation());
1549	E->setReceiverLocation(readSourceLocation());
1550	switch (Record.readInt()) {
1551	case 0:
1552	E->setBase(Record.readSubExpr());
1553	break;
1554	case 1:
1555	E->setSuperReceiver(Record.readType());
1556	break;
1557	case 2:
1558	E->setClassReceiver(readDeclAs<ObjCInterfaceDecl>());
1559	break;
1560	}
1561	}
1562
1563	void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1564	VisitExpr(E);
1565	E->setRBracket(readSourceLocation());
1566	E->setBaseExpr(Record.readSubExpr());
1567	E->setKeyExpr(Record.readSubExpr());
1568	E->GetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>();
1569	E->SetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>();
1570	}
1571
1572	void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1573	VisitExpr(E);
1574	assert(Record.peekInt() == E->getNumArgs());
1575	Record.skipInts(N: 1);
1576	unsigned NumStoredSelLocs = Record.readInt();
1577	E->SelLocsKind = Record.readInt();
1578	E->setDelegateInitCall(Record.readInt());
1579	E->IsImplicit = Record.readInt();
1580	auto Kind = static_cast<ObjCMessageExpr::ReceiverKind>(Record.readInt());
1581	switch (Kind) {
1582	case ObjCMessageExpr::Instance:
1583	E->setInstanceReceiver(Record.readSubExpr());
1584	break;
1585
1586	case ObjCMessageExpr::Class:
1587	E->setClassReceiver(readTypeSourceInfo());
1588	break;
1589
1590	case ObjCMessageExpr::SuperClass:
1591	case ObjCMessageExpr::SuperInstance: {
1592	QualType T = Record.readType();
1593	SourceLocation SuperLoc = readSourceLocation();
1594	E->setSuper(Loc: SuperLoc, T, IsInstanceSuper: Kind == ObjCMessageExpr::SuperInstance);
1595	break;
1596	}
1597	}
1598
1599	assert(Kind == E->getReceiverKind());
1600
1601	if (Record.readInt())
1602	E->setMethodDecl(readDeclAs<ObjCMethodDecl>());
1603	else
1604	E->setSelector(Record.readSelector());
1605
1606	E->LBracLoc = readSourceLocation();
1607	E->RBracLoc = readSourceLocation();
1608
1609	for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1610	E->setArg(Arg: I, ArgExpr: Record.readSubExpr());
1611
1612	SourceLocation *Locs = E->getStoredSelLocs();
1613	for (unsigned I = 0; I != NumStoredSelLocs; ++I)
1614	Locs[I] = readSourceLocation();
1615	}
1616
1617	void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
1618	VisitStmt(S);
1619	S->setElement(Record.readSubStmt());
1620	S->setCollection(Record.readSubExpr());
1621	S->setBody(Record.readSubStmt());
1622	S->setForLoc(readSourceLocation());
1623	S->setRParenLoc(readSourceLocation());
1624	}
1625
1626	void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
1627	VisitStmt(S);
1628	S->setCatchBody(Record.readSubStmt());
1629	S->setCatchParamDecl(readDeclAs<VarDecl>());
1630	S->setAtCatchLoc(readSourceLocation());
1631	S->setRParenLoc(readSourceLocation());
1632	}
1633
1634	void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
1635	VisitStmt(S);
1636	S->setFinallyBody(Record.readSubStmt());
1637	S->setAtFinallyLoc(readSourceLocation());
1638	}
1639
1640	void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1641	VisitStmt(S); // FIXME: no test coverage.
1642	S->setSubStmt(Record.readSubStmt());
1643	S->setAtLoc(readSourceLocation());
1644	}
1645
1646	void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
1647	VisitStmt(S);
1648	assert(Record.peekInt() == S->getNumCatchStmts());
1649	Record.skipInts(N: 1);
1650	bool HasFinally = Record.readInt();
1651	S->setTryBody(Record.readSubStmt());
1652	for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
1653	S->setCatchStmt(I, S: cast_or_null<ObjCAtCatchStmt>(Val: Record.readSubStmt()));
1654
1655	if (HasFinally)
1656	S->setFinallyStmt(Record.readSubStmt());
1657	S->setAtTryLoc(readSourceLocation());
1658	}
1659
1660	void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1661	VisitStmt(S); // FIXME: no test coverage.
1662	S->setSynchExpr(Record.readSubStmt());
1663	S->setSynchBody(Record.readSubStmt());
1664	S->setAtSynchronizedLoc(readSourceLocation());
1665	}
1666
1667	void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
1668	VisitStmt(S); // FIXME: no test coverage.
1669	S->setThrowExpr(Record.readSubStmt());
1670	S->setThrowLoc(readSourceLocation());
1671	}
1672
1673	void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1674	VisitExpr(E);
1675	E->setValue(Record.readInt());
1676	E->setLocation(readSourceLocation());
1677	}
1678
1679	void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
1680	VisitExpr(E);
1681	SourceRange R = Record.readSourceRange();
1682	E->AtLoc = R.getBegin();
1683	E->RParen = R.getEnd();
1684	E->VersionToCheck = Record.readVersionTuple();
1685	}
1686
1687	//===----------------------------------------------------------------------===//
1688	// C++ Expressions and Statements
1689	//===----------------------------------------------------------------------===//
1690
1691	void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
1692	VisitStmt(S);
1693	S->CatchLoc = readSourceLocation();
1694	S->ExceptionDecl = readDeclAs<VarDecl>();
1695	S->HandlerBlock = Record.readSubStmt();
1696	}
1697
1698	void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
1699	VisitStmt(S);
1700	assert(Record.peekInt() == S->getNumHandlers() && "NumStmtFields is wrong ?");
1701	Record.skipInts(N: 1);
1702	S->TryLoc = readSourceLocation();
1703	S->getStmts()[0] = Record.readSubStmt();
1704	for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1705	S->getStmts()[i + 1] = Record.readSubStmt();
1706	}
1707
1708	void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1709	VisitStmt(S);
1710	S->ForLoc = readSourceLocation();
1711	S->CoawaitLoc = readSourceLocation();
1712	S->ColonLoc = readSourceLocation();
1713	S->RParenLoc = readSourceLocation();
1714	S->setInit(Record.readSubStmt());
1715	S->setRangeStmt(Record.readSubStmt());
1716	S->setBeginStmt(Record.readSubStmt());
1717	S->setEndStmt(Record.readSubStmt());
1718	S->setCond(Record.readSubExpr());
1719	S->setInc(Record.readSubExpr());
1720	S->setLoopVarStmt(Record.readSubStmt());
1721	S->setBody(Record.readSubStmt());
1722	}
1723
1724	void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1725	VisitStmt(S);
1726	S->KeywordLoc = readSourceLocation();
1727	S->IsIfExists = Record.readInt();
1728	S->QualifierLoc = Record.readNestedNameSpecifierLoc();
1729	S->NameInfo = Record.readDeclarationNameInfo();
1730	S->SubStmt = Record.readSubStmt();
1731	}
1732
1733	void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1734	VisitCallExpr(E);
1735	E->CXXOperatorCallExprBits.OperatorKind = Record.readInt();
1736	E->Range = Record.readSourceRange();
1737	}
1738
1739	void ASTStmtReader::VisitCXXRewrittenBinaryOperator(
1740	CXXRewrittenBinaryOperator *E) {
1741	VisitExpr(E);
1742	E->CXXRewrittenBinaryOperatorBits.IsReversed = Record.readInt();
1743	E->SemanticForm = Record.readSubExpr();
1744	}
1745
1746	void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
1747	VisitExpr(E);
1748
1749	unsigned NumArgs = Record.readInt();
1750	assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
1751
1752	E->CXXConstructExprBits.Elidable = Record.readInt();
1753	E->CXXConstructExprBits.HadMultipleCandidates = Record.readInt();
1754	E->CXXConstructExprBits.ListInitialization = Record.readInt();
1755	E->CXXConstructExprBits.StdInitListInitialization = Record.readInt();
1756	E->CXXConstructExprBits.ZeroInitialization = Record.readInt();
1757	E->CXXConstructExprBits.ConstructionKind = Record.readInt();
1758	E->CXXConstructExprBits.IsImmediateEscalating = Record.readInt();
1759	E->CXXConstructExprBits.Loc = readSourceLocation();
1760	E->Constructor = readDeclAs<CXXConstructorDecl>();
1761	E->ParenOrBraceRange = readSourceRange();
1762
1763	for (unsigned I = 0; I != NumArgs; ++I)
1764	E->setArg(Arg: I, ArgExpr: Record.readSubExpr());
1765	}
1766
1767	void ASTStmtReader::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
1768	VisitExpr(E);
1769	E->Constructor = readDeclAs<CXXConstructorDecl>();
1770	E->Loc = readSourceLocation();
1771	E->ConstructsVirtualBase = Record.readInt();
1772	E->InheritedFromVirtualBase = Record.readInt();
1773	}
1774
1775	void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1776	VisitCXXConstructExpr(E);
1777	E->TSI = readTypeSourceInfo();
1778	}
1779
1780	void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {
1781	VisitExpr(E);
1782	unsigned NumCaptures = Record.readInt();
1783	(void)NumCaptures;
1784	assert(NumCaptures == E->LambdaExprBits.NumCaptures);
1785	E->IntroducerRange = readSourceRange();
1786	E->LambdaExprBits.CaptureDefault = Record.readInt();
1787	E->CaptureDefaultLoc = readSourceLocation();
1788	E->LambdaExprBits.ExplicitParams = Record.readInt();
1789	E->LambdaExprBits.ExplicitResultType = Record.readInt();
1790	E->ClosingBrace = readSourceLocation();
1791
1792	// Read capture initializers.
1793	for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1794	CEnd = E->capture_init_end();
1795	C != CEnd; ++C)
1796	*C = Record.readSubExpr();
1797
1798	// The body will be lazily deserialized when needed from the call operator
1799	// declaration.
1800	}
1801
1802	void
1803	ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1804	VisitExpr(E);
1805	E->SubExpr = Record.readSubExpr();
1806	}
1807
1808	void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1809	VisitExplicitCastExpr(E);
1810	SourceRange R = readSourceRange();
1811	E->Loc = R.getBegin();
1812	E->RParenLoc = R.getEnd();
1813	if (CurrentUnpackingBits->getNextBit())
1814	E->AngleBrackets = readSourceRange();
1815	}
1816
1817	void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1818	return VisitCXXNamedCastExpr(E);
1819	}
1820
1821	void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1822	return VisitCXXNamedCastExpr(E);
1823	}
1824
1825	void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1826	return VisitCXXNamedCastExpr(E);
1827	}
1828
1829	void ASTStmtReader::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) {
1830	return VisitCXXNamedCastExpr(E);
1831	}
1832
1833	void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1834	return VisitCXXNamedCastExpr(E);
1835	}
1836
1837	void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1838	VisitExplicitCastExpr(E);
1839	E->setLParenLoc(readSourceLocation());
1840	E->setRParenLoc(readSourceLocation());
1841	}
1842
1843	void ASTStmtReader::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) {
1844	VisitExplicitCastExpr(E);
1845	E->KWLoc = readSourceLocation();
1846	E->RParenLoc = readSourceLocation();
1847	}
1848
1849	void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1850	VisitCallExpr(E);
1851	E->UDSuffixLoc = readSourceLocation();
1852	}
1853
1854	void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1855	VisitExpr(E);
1856	E->setValue(Record.readInt());
1857	E->setLocation(readSourceLocation());
1858	}
1859
1860	void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1861	VisitExpr(E);
1862	E->setLocation(readSourceLocation());
1863	}
1864
1865	void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1866	VisitExpr(E);
1867	E->setSourceRange(readSourceRange());
1868	if (E->isTypeOperand())
1869	E->Operand = readTypeSourceInfo();
1870	else
1871	E->Operand = Record.readSubExpr();
1872	}
1873
1874	void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1875	VisitExpr(E);
1876	E->setLocation(readSourceLocation());
1877	E->setImplicit(Record.readInt());
1878	E->setCapturedByCopyInLambdaWithExplicitObjectParameter(Record.readInt());
1879	}
1880
1881	void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1882	VisitExpr(E);
1883	E->CXXThrowExprBits.ThrowLoc = readSourceLocation();
1884	E->Operand = Record.readSubExpr();
1885	E->CXXThrowExprBits.IsThrownVariableInScope = Record.readInt();
1886	}
1887
1888	void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1889	VisitExpr(E);
1890	E->Param = readDeclAs<ParmVarDecl>();
1891	E->UsedContext = readDeclAs<DeclContext>();
1892	E->CXXDefaultArgExprBits.Loc = readSourceLocation();
1893	E->CXXDefaultArgExprBits.HasRewrittenInit = Record.readInt();
1894	if (E->CXXDefaultArgExprBits.HasRewrittenInit)
1895	*E->getTrailingObjects<Expr *>() = Record.readSubExpr();
1896	}
1897
1898	void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1899	VisitExpr(E);
1900	E->CXXDefaultInitExprBits.HasRewrittenInit = Record.readInt();
1901	E->Field = readDeclAs<FieldDecl>();
1902	E->UsedContext = readDeclAs<DeclContext>();
1903	E->CXXDefaultInitExprBits.Loc = readSourceLocation();
1904	if (E->CXXDefaultInitExprBits.HasRewrittenInit)
1905	*E->getTrailingObjects<Expr *>() = Record.readSubExpr();
1906	}
1907
1908	void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1909	VisitExpr(E);
1910	E->setTemporary(Record.readCXXTemporary());
1911	E->setSubExpr(Record.readSubExpr());
1912	}
1913
1914	void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1915	VisitExpr(E);
1916	E->TypeInfo = readTypeSourceInfo();
1917	E->CXXScalarValueInitExprBits.RParenLoc = readSourceLocation();
1918	}
1919
1920	void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1921	VisitExpr(E);
1922
1923	bool IsArray = Record.readInt();
1924	bool HasInit = Record.readInt();
1925	unsigned NumPlacementArgs = Record.readInt();
1926	bool IsParenTypeId = Record.readInt();
1927
1928	E->CXXNewExprBits.IsGlobalNew = Record.readInt();
1929	E->CXXNewExprBits.ShouldPassAlignment = Record.readInt();
1930	E->CXXNewExprBits.ShouldPassTypeIdentity = Record.readInt();
1931	E->CXXNewExprBits.UsualArrayDeleteWantsSize = Record.readInt();
1932	E->CXXNewExprBits.HasInitializer = Record.readInt();
1933	E->CXXNewExprBits.StoredInitializationStyle = Record.readInt();
1934
1935	assert((IsArray == E->isArray()) && "Wrong IsArray!");
1936	assert((HasInit == E->hasInitializer()) && "Wrong HasInit!");
1937	assert((NumPlacementArgs == E->getNumPlacementArgs()) &&
1938	"Wrong NumPlacementArgs!");
1939	assert((IsParenTypeId == E->isParenTypeId()) && "Wrong IsParenTypeId!");
1940	(void)IsArray;
1941	(void)HasInit;
1942	(void)NumPlacementArgs;
1943
1944	E->setOperatorNew(readDeclAs<FunctionDecl>());
1945	E->setOperatorDelete(readDeclAs<FunctionDecl>());
1946	E->AllocatedTypeInfo = readTypeSourceInfo();
1947	if (IsParenTypeId)
1948	E->getTrailingObjects<SourceRange>()[0] = readSourceRange();
1949	E->Range = readSourceRange();
1950	E->DirectInitRange = readSourceRange();
1951
1952	// Install all the subexpressions.
1953	for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),
1954	N = E->raw_arg_end();
1955	I != N; ++I)
1956	*I = Record.readSubStmt();
1957	}
1958
1959	void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1960	VisitExpr(E);
1961	E->CXXDeleteExprBits.GlobalDelete = Record.readInt();
1962	E->CXXDeleteExprBits.ArrayForm = Record.readInt();
1963	E->CXXDeleteExprBits.ArrayFormAsWritten = Record.readInt();
1964	E->CXXDeleteExprBits.UsualArrayDeleteWantsSize = Record.readInt();
1965	E->OperatorDelete = readDeclAs<FunctionDecl>();
1966	E->Argument = Record.readSubExpr();
1967	E->CXXDeleteExprBits.Loc = readSourceLocation();
1968	}
1969
1970	void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1971	VisitExpr(E);
1972
1973	E->Base = Record.readSubExpr();
1974	E->IsArrow = Record.readInt();
1975	E->OperatorLoc = readSourceLocation();
1976	E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1977	E->ScopeType = readTypeSourceInfo();
1978	E->ColonColonLoc = readSourceLocation();
1979	E->TildeLoc = readSourceLocation();
1980
1981	IdentifierInfo *II = Record.readIdentifier();
1982	if (II)
1983	E->setDestroyedType(II, Loc: readSourceLocation());
1984	else
1985	E->setDestroyedType(readTypeSourceInfo());
1986	}
1987
1988	void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
1989	VisitExpr(E);
1990
1991	unsigned NumObjects = Record.readInt();
1992	assert(NumObjects == E->getNumObjects());
1993	for (unsigned i = 0; i != NumObjects; ++i) {
1994	unsigned CleanupKind = Record.readInt();
1995	ExprWithCleanups::CleanupObject Obj;
1996	if (CleanupKind == COK_Block)
1997	Obj = readDeclAs<BlockDecl>();
1998	else if (CleanupKind == COK_CompoundLiteral)
1999	Obj = cast<CompoundLiteralExpr>(Val: Record.readSubExpr());
2000	else
2001	llvm_unreachable("unexpected cleanup object type");
2002	E->getTrailingObjects<ExprWithCleanups::CleanupObject>()[i] = Obj;
2003	}
2004
2005	E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record.readInt();
2006	E->SubExpr = Record.readSubExpr();
2007	}
2008
2009	void ASTStmtReader::VisitCXXDependentScopeMemberExpr(
2010	CXXDependentScopeMemberExpr *E) {
2011	VisitExpr(E);
2012
2013	unsigned NumTemplateArgs = Record.readInt();
2014	CurrentUnpackingBits.emplace(args: Record.readInt());
2015	bool HasTemplateKWAndArgsInfo = CurrentUnpackingBits->getNextBit();
2016	bool HasFirstQualifierFoundInScope = CurrentUnpackingBits->getNextBit();
2017
2018	assert((HasTemplateKWAndArgsInfo == E->hasTemplateKWAndArgsInfo()) &&
2019	"Wrong HasTemplateKWAndArgsInfo!");
2020	assert(
2021	(HasFirstQualifierFoundInScope == E->hasFirstQualifierFoundInScope()) &&
2022	"Wrong HasFirstQualifierFoundInScope!");
2023
2024	if (HasTemplateKWAndArgsInfo)
2025	ReadTemplateKWAndArgsInfo(
2026	Args&: *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
2027	ArgsLocArray: E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
2028
2029	assert((NumTemplateArgs == E->getNumTemplateArgs()) &&
2030	"Wrong NumTemplateArgs!");
2031
2032	E->CXXDependentScopeMemberExprBits.IsArrow =
2033	CurrentUnpackingBits->getNextBit();
2034
2035	E->BaseType = Record.readType();
2036	E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2037	// not ImplicitAccess
2038	if (CurrentUnpackingBits->getNextBit())
2039	E->Base = Record.readSubExpr();
2040	else
2041	E->Base = nullptr;
2042
2043	E->CXXDependentScopeMemberExprBits.OperatorLoc = readSourceLocation();
2044
2045	if (HasFirstQualifierFoundInScope)
2046	*E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>();
2047
2048	E->MemberNameInfo = Record.readDeclarationNameInfo();
2049	}
2050
2051	void
2052	ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
2053	VisitExpr(E);
2054
2055	if (CurrentUnpackingBits->getNextBit()) // HasTemplateKWAndArgsInfo
2056	ReadTemplateKWAndArgsInfo(
2057	Args&: *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
2058	ArgsLocArray: E->getTrailingObjects<TemplateArgumentLoc>(),
2059	/*NumTemplateArgs=*/CurrentUnpackingBits->getNextBits(/*Width=*/16));
2060
2061	E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2062	E->NameInfo = Record.readDeclarationNameInfo();
2063	}
2064
2065	void
2066	ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
2067	VisitExpr(E);
2068	assert(Record.peekInt() == E->getNumArgs() &&
2069	"Read wrong record during creation ?");
2070	Record.skipInts(N: 1);
2071	for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
2072	E->setArg(I, E: Record.readSubExpr());
2073	E->TypeAndInitForm.setPointer(readTypeSourceInfo());
2074	E->setLParenLoc(readSourceLocation());
2075	E->setRParenLoc(readSourceLocation());
2076	E->TypeAndInitForm.setInt(Record.readInt());
2077	}
2078
2079	void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
2080	VisitExpr(E);
2081
2082	unsigned NumResults = Record.readInt();
2083	CurrentUnpackingBits.emplace(args: Record.readInt());
2084	bool HasTemplateKWAndArgsInfo = CurrentUnpackingBits->getNextBit();
2085	assert((E->getNumDecls() == NumResults) && "Wrong NumResults!");
2086	assert((E->hasTemplateKWAndArgsInfo() == HasTemplateKWAndArgsInfo) &&
2087	"Wrong HasTemplateKWAndArgsInfo!");
2088
2089	if (HasTemplateKWAndArgsInfo) {
2090	unsigned NumTemplateArgs = Record.readInt();
2091	ReadTemplateKWAndArgsInfo(Args&: *E->getTrailingASTTemplateKWAndArgsInfo(),
2092	ArgsLocArray: E->getTrailingTemplateArgumentLoc(),
2093	NumTemplateArgs);
2094	assert((E->getNumTemplateArgs() == NumTemplateArgs) &&
2095	"Wrong NumTemplateArgs!");
2096	}
2097
2098	UnresolvedSet<8> Decls;
2099	for (unsigned I = 0; I != NumResults; ++I) {
2100	auto *D = readDeclAs<NamedDecl>();
2101	auto AS = (AccessSpecifier)Record.readInt();
2102	Decls.addDecl(D, AS);
2103	}
2104
2105	DeclAccessPair *Results = E->getTrailingResults();
2106	UnresolvedSetIterator Iter = Decls.begin();
2107	for (unsigned I = 0; I != NumResults; ++I) {
2108	Results[I] = (Iter + I).getPair();
2109	}
2110
2111	E->NameInfo = Record.readDeclarationNameInfo();
2112	E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2113	}
2114
2115	void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
2116	VisitOverloadExpr(E);
2117	E->UnresolvedMemberExprBits.IsArrow = CurrentUnpackingBits->getNextBit();
2118	E->UnresolvedMemberExprBits.HasUnresolvedUsing =
2119	CurrentUnpackingBits->getNextBit();
2120
2121	if (/*!isImplicitAccess=*/CurrentUnpackingBits->getNextBit())
2122	E->Base = Record.readSubExpr();
2123	else
2124	E->Base = nullptr;
2125
2126	E->OperatorLoc = readSourceLocation();
2127
2128	E->BaseType = Record.readType();
2129	}
2130
2131	void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
2132	VisitOverloadExpr(E);
2133	E->UnresolvedLookupExprBits.RequiresADL = CurrentUnpackingBits->getNextBit();
2134	E->NamingClass = readDeclAs<CXXRecordDecl>();
2135	}
2136
2137	void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {
2138	VisitExpr(E);
2139	E->TypeTraitExprBits.IsBooleanTypeTrait = Record.readInt();
2140	E->TypeTraitExprBits.NumArgs = Record.readInt();
2141	E->TypeTraitExprBits.Kind = Record.readInt();
2142
2143	if (E->TypeTraitExprBits.IsBooleanTypeTrait)
2144	E->TypeTraitExprBits.Value = Record.readInt();
2145	else
2146	*E->getTrailingObjects<APValue>() = Record.readAPValue();
2147
2148	SourceRange Range = readSourceRange();
2149	E->Loc = Range.getBegin();
2150	E->RParenLoc = Range.getEnd();
2151
2152	auto **Args = E->getTrailingObjects<TypeSourceInfo *>();
2153	for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
2154	Args[I] = readTypeSourceInfo();
2155	}
2156
2157	void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
2158	VisitExpr(E);
2159	E->ArrayTypeTraitExprBits.ATT = (ArrayTypeTrait)Record.readInt();
2160	E->Value = (unsigned int)Record.readInt();
2161	SourceRange Range = readSourceRange();
2162	E->Loc = Range.getBegin();
2163	E->RParen = Range.getEnd();
2164	E->QueriedType = readTypeSourceInfo();
2165	E->Dimension = Record.readSubExpr();
2166	}
2167
2168	void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
2169	VisitExpr(E);
2170	E->ExpressionTraitExprBits.ET = (ExpressionTrait)Record.readInt();
2171	E->ExpressionTraitExprBits.Value = (bool)Record.readInt();
2172	SourceRange Range = readSourceRange();
2173	E->QueriedExpression = Record.readSubExpr();
2174	E->Loc = Range.getBegin();
2175	E->RParen = Range.getEnd();
2176	}
2177
2178	void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
2179	VisitExpr(E);
2180	E->CXXNoexceptExprBits.Value = Record.readInt();
2181	E->Range = readSourceRange();
2182	E->Operand = Record.readSubExpr();
2183	}
2184
2185	void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
2186	VisitExpr(E);
2187	E->EllipsisLoc = readSourceLocation();
2188	E->NumExpansions = Record.readInt();
2189	E->Pattern = Record.readSubExpr();
2190	}
2191
2192	void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
2193	VisitExpr(E);
2194	unsigned NumPartialArgs = Record.readInt();
2195	E->OperatorLoc = readSourceLocation();
2196	E->PackLoc = readSourceLocation();
2197	E->RParenLoc = readSourceLocation();
2198	E->Pack = Record.readDeclAs<NamedDecl>();
2199	if (E->isPartiallySubstituted()) {
2200	assert(E->Length == NumPartialArgs);
2201	for (auto *I = E->getTrailingObjects<TemplateArgument>(),
2202	*E = I + NumPartialArgs;
2203	I != E; ++I)
2204	new (I) TemplateArgument(Record.readTemplateArgument());
2205	} else if (!E->isValueDependent()) {
2206	E->Length = Record.readInt();
2207	}
2208	}
2209
2210	void ASTStmtReader::VisitPackIndexingExpr(PackIndexingExpr *E) {
2211	VisitExpr(E);
2212	E->PackIndexingExprBits.TransformedExpressions = Record.readInt();
2213	E->PackIndexingExprBits.FullySubstituted = Record.readInt();
2214	E->EllipsisLoc = readSourceLocation();
2215	E->RSquareLoc = readSourceLocation();
2216	E->SubExprs[0] = Record.readStmt();
2217	E->SubExprs[1] = Record.readStmt();
2218	auto **Exprs = E->getTrailingObjects<Expr *>();
2219	for (unsigned I = 0; I < E->PackIndexingExprBits.TransformedExpressions; ++I)
2220	Exprs[I] = Record.readExpr();
2221	}
2222
2223	void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(
2224	SubstNonTypeTemplateParmExpr *E) {
2225	VisitExpr(E);
2226	E->AssociatedDeclAndRef.setPointer(readDeclAs<Decl>());
2227	E->AssociatedDeclAndRef.setInt(CurrentUnpackingBits->getNextBit());
2228	E->Index = CurrentUnpackingBits->getNextBits(/*Width=*/12);
2229	E->PackIndex = Record.readUnsignedOrNone().toInternalRepresentation();
2230	E->Final = CurrentUnpackingBits->getNextBit();
2231	E->SubstNonTypeTemplateParmExprBits.NameLoc = readSourceLocation();
2232	E->Replacement = Record.readSubExpr();
2233	}
2234
2235	void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
2236	SubstNonTypeTemplateParmPackExpr *E) {
2237	VisitExpr(E);
2238	E->AssociatedDecl = readDeclAs<Decl>();
2239	E->Final = CurrentUnpackingBits->getNextBit();
2240	E->Index = Record.readInt();
2241	TemplateArgument ArgPack = Record.readTemplateArgument();
2242	if (ArgPack.getKind() != TemplateArgument::Pack)
2243	return;
2244
2245	E->Arguments = ArgPack.pack_begin();
2246	E->NumArguments = ArgPack.pack_size();
2247	E->NameLoc = readSourceLocation();
2248	}
2249
2250	void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
2251	VisitExpr(E);
2252	E->NumParameters = Record.readInt();
2253	E->ParamPack = readDeclAs<ValueDecl>();
2254	E->NameLoc = readSourceLocation();
2255	auto **Parms = E->getTrailingObjects<ValueDecl *>();
2256	for (unsigned i = 0, n = E->NumParameters; i != n; ++i)
2257	Parms[i] = readDeclAs<ValueDecl>();
2258	}
2259
2260	void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
2261	VisitExpr(E);
2262	bool HasMaterialzedDecl = Record.readInt();
2263	if (HasMaterialzedDecl)
2264	E->State = cast<LifetimeExtendedTemporaryDecl>(Val: Record.readDecl());
2265	else
2266	E->State = Record.readSubExpr();
2267	}
2268
2269	void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {
2270	VisitExpr(E);
2271	E->LParenLoc = readSourceLocation();
2272	E->EllipsisLoc = readSourceLocation();
2273	E->RParenLoc = readSourceLocation();
2274	E->NumExpansions = Record.readUnsignedOrNone();
2275	E->SubExprs[0] = Record.readSubExpr();
2276	E->SubExprs[1] = Record.readSubExpr();
2277	E->SubExprs[2] = Record.readSubExpr();
2278	E->CXXFoldExprBits.Opcode = (BinaryOperatorKind)Record.readInt();
2279	}
2280
2281	void ASTStmtReader::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) {
2282	VisitExpr(E);
2283	unsigned ExpectedNumExprs = Record.readInt();
2284	assert(E->NumExprs == ExpectedNumExprs &&
2285	"expected number of expressions does not equal the actual number of "
2286	"serialized expressions.");
2287	E->NumUserSpecifiedExprs = Record.readInt();
2288	E->InitLoc = readSourceLocation();
2289	E->LParenLoc = readSourceLocation();
2290	E->RParenLoc = readSourceLocation();
2291	for (unsigned I = 0; I < ExpectedNumExprs; I++)
2292	E->getTrailingObjects<Expr *>()[I] = Record.readSubExpr();
2293
2294	bool HasArrayFillerOrUnionDecl = Record.readBool();
2295	if (HasArrayFillerOrUnionDecl) {
2296	bool HasArrayFiller = Record.readBool();
2297	if (HasArrayFiller) {
2298	E->setArrayFiller(Record.readSubExpr());
2299	} else {
2300	E->setInitializedFieldInUnion(readDeclAs<FieldDecl>());
2301	}
2302	}
2303	E->updateDependence();
2304	}
2305
2306	void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
2307	VisitExpr(E);
2308	E->SourceExpr = Record.readSubExpr();
2309	E->OpaqueValueExprBits.Loc = readSourceLocation();
2310	E->setIsUnique(Record.readInt());
2311	}
2312
2313	void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {
2314	llvm_unreachable("Cannot read TypoExpr nodes");
2315	}
2316
2317	void ASTStmtReader::VisitRecoveryExpr(RecoveryExpr *E) {
2318	VisitExpr(E);
2319	unsigned NumArgs = Record.readInt();
2320	E->BeginLoc = readSourceLocation();
2321	E->EndLoc = readSourceLocation();
2322	assert((NumArgs + 0LL ==
2323	std::distance(E->children().begin(), E->children().end())) &&
2324	"Wrong NumArgs!");
2325	(void)NumArgs;
2326	for (Stmt *&Child : E->children())
2327	Child = Record.readSubStmt();
2328	}
2329
2330	//===----------------------------------------------------------------------===//
2331	// Microsoft Expressions and Statements
2332	//===----------------------------------------------------------------------===//
2333	void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
2334	VisitExpr(E);
2335	E->IsArrow = (Record.readInt() != 0);
2336	E->BaseExpr = Record.readSubExpr();
2337	E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2338	E->MemberLoc = readSourceLocation();
2339	E->TheDecl = readDeclAs<MSPropertyDecl>();
2340	}
2341
2342	void ASTStmtReader::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
2343	VisitExpr(E);
2344	E->setBase(Record.readSubExpr());
2345	E->setIdx(Record.readSubExpr());
2346	E->setRBracketLoc(readSourceLocation());
2347	}
2348
2349	void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
2350	VisitExpr(E);
2351	E->setSourceRange(readSourceRange());
2352	E->Guid = readDeclAs<MSGuidDecl>();
2353	if (E->isTypeOperand())
2354	E->Operand = readTypeSourceInfo();
2355	else
2356	E->Operand = Record.readSubExpr();
2357	}
2358
2359	void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
2360	VisitStmt(S);
2361	S->setLeaveLoc(readSourceLocation());
2362	}
2363
2364	void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {
2365	VisitStmt(S);
2366	S->Loc = readSourceLocation();
2367	S->Children[SEHExceptStmt::FILTER_EXPR] = Record.readSubStmt();
2368	S->Children[SEHExceptStmt::BLOCK] = Record.readSubStmt();
2369	}
2370
2371	void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
2372	VisitStmt(S);
2373	S->Loc = readSourceLocation();
2374	S->Block = Record.readSubStmt();
2375	}
2376
2377	void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {
2378	VisitStmt(S);
2379	S->IsCXXTry = Record.readInt();
2380	S->TryLoc = readSourceLocation();
2381	S->Children[SEHTryStmt::TRY] = Record.readSubStmt();
2382	S->Children[SEHTryStmt::HANDLER] = Record.readSubStmt();
2383	}
2384
2385	//===----------------------------------------------------------------------===//
2386	// CUDA Expressions and Statements
2387	//===----------------------------------------------------------------------===//
2388
2389	void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
2390	VisitCallExpr(E);
2391	E->setPreArg(CUDAKernelCallExpr::CONFIG, Record.readSubExpr());
2392	}
2393
2394	//===----------------------------------------------------------------------===//
2395	// OpenCL Expressions and Statements.
2396	//===----------------------------------------------------------------------===//
2397	void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
2398	VisitExpr(E);
2399	E->BuiltinLoc = readSourceLocation();
2400	E->RParenLoc = readSourceLocation();
2401	E->SrcExpr = Record.readSubExpr();
2402	}
2403
2404	//===----------------------------------------------------------------------===//
2405	// OpenMP Directives.
2406	//===----------------------------------------------------------------------===//
2407
2408	void ASTStmtReader::VisitOMPCanonicalLoop(OMPCanonicalLoop *S) {
2409	VisitStmt(S);
2410	for (Stmt *&SubStmt : S->SubStmts)
2411	SubStmt = Record.readSubStmt();
2412	}
2413
2414	void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2415	Record.readOMPChildren(Data: E->Data);
2416	E->setLocStart(readSourceLocation());
2417	E->setLocEnd(readSourceLocation());
2418	}
2419
2420	void ASTStmtReader::VisitOMPLoopBasedDirective(OMPLoopBasedDirective *D) {
2421	VisitStmt(D);
2422	// Field CollapsedNum was read in ReadStmtFromStream.
2423	Record.skipInts(N: 1);
2424	VisitOMPExecutableDirective(D);
2425	}
2426
2427	void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) {
2428	VisitOMPLoopBasedDirective(D);
2429	}
2430
2431	void ASTStmtReader::VisitOMPMetaDirective(OMPMetaDirective *D) {
2432	VisitStmt(D);
2433	// The NumClauses field was read in ReadStmtFromStream.
2434	Record.skipInts(N: 1);
2435	VisitOMPExecutableDirective(D);
2436	}
2437
2438	void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) {
2439	VisitStmt(D);
2440	VisitOMPExecutableDirective(D);
2441	D->setHasCancel(Record.readBool());
2442	}
2443
2444	void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) {
2445	VisitOMPLoopDirective(D);
2446	}
2447
2448	void ASTStmtReader::VisitOMPLoopTransformationDirective(
2449	OMPLoopTransformationDirective *D) {
2450	VisitOMPLoopBasedDirective(D);
2451	D->setNumGeneratedLoops(Record.readUInt32());
2452	}
2453
2454	void ASTStmtReader::VisitOMPTileDirective(OMPTileDirective *D) {
2455	VisitOMPLoopTransformationDirective(D);
2456	}
2457
2458	void ASTStmtReader::VisitOMPStripeDirective(OMPStripeDirective *D) {
2459	VisitOMPLoopTransformationDirective(D);
2460	}
2461
2462	void ASTStmtReader::VisitOMPUnrollDirective(OMPUnrollDirective *D) {
2463	VisitOMPLoopTransformationDirective(D);
2464	}
2465
2466	void ASTStmtReader::VisitOMPReverseDirective(OMPReverseDirective *D) {
2467	VisitOMPLoopTransformationDirective(D);
2468	}
2469
2470	void ASTStmtReader::VisitOMPInterchangeDirective(OMPInterchangeDirective *D) {
2471	VisitOMPLoopTransformationDirective(D);
2472	}
2473
2474	void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) {
2475	VisitOMPLoopDirective(D);
2476	D->setHasCancel(Record.readBool());
2477	}
2478
2479	void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
2480	VisitOMPLoopDirective(D);
2481	}
2482
2483	void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
2484	VisitStmt(D);
2485	VisitOMPExecutableDirective(D);
2486	D->setHasCancel(Record.readBool());
2487	}
2488
2489	void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) {
2490	VisitStmt(D);
2491	VisitOMPExecutableDirective(D);
2492	D->setHasCancel(Record.readBool());
2493	}
2494
2495	void ASTStmtReader::VisitOMPScopeDirective(OMPScopeDirective *D) {
2496	VisitStmt(D);
2497	VisitOMPExecutableDirective(D);
2498	}
2499
2500	void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) {
2501	VisitStmt(D);
2502	VisitOMPExecutableDirective(D);
2503	}
2504
2505	void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) {
2506	VisitStmt(D);
2507	VisitOMPExecutableDirective(D);
2508	}
2509
2510	void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2511	VisitStmt(D);
2512	VisitOMPExecutableDirective(D);
2513	D->DirName = Record.readDeclarationNameInfo();
2514	}
2515
2516	void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2517	VisitOMPLoopDirective(D);
2518	D->setHasCancel(Record.readBool());
2519	}
2520
2521	void ASTStmtReader::VisitOMPParallelForSimdDirective(
2522	OMPParallelForSimdDirective *D) {
2523	VisitOMPLoopDirective(D);
2524	}
2525
2526	void ASTStmtReader::VisitOMPParallelMasterDirective(
2527	OMPParallelMasterDirective *D) {
2528	VisitStmt(D);
2529	VisitOMPExecutableDirective(D);
2530	}
2531
2532	void ASTStmtReader::VisitOMPParallelMaskedDirective(
2533	OMPParallelMaskedDirective *D) {
2534	VisitStmt(D);
2535	VisitOMPExecutableDirective(D);
2536	}
2537
2538	void ASTStmtReader::VisitOMPParallelSectionsDirective(
2539	OMPParallelSectionsDirective *D) {
2540	VisitStmt(D);
2541	VisitOMPExecutableDirective(D);
2542	D->setHasCancel(Record.readBool());
2543	}
2544
2545	void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) {
2546	VisitStmt(D);
2547	VisitOMPExecutableDirective(D);
2548	D->setHasCancel(Record.readBool());
2549	}
2550
2551	void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2552	VisitStmt(D);
2553	VisitOMPExecutableDirective(D);
2554	}
2555
2556	void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2557	VisitStmt(D);
2558	VisitOMPExecutableDirective(D);
2559	}
2560
2561	void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2562	VisitStmt(D);
2563	// The NumClauses field was read in ReadStmtFromStream.
2564	Record.skipInts(N: 1);
2565	VisitOMPExecutableDirective(D);
2566	}
2567
2568	void ASTStmtReader::VisitOMPAssumeDirective(OMPAssumeDirective *D) {
2569	VisitStmt(D);
2570	VisitOMPExecutableDirective(D);
2571	}
2572
2573	void ASTStmtReader::VisitOMPErrorDirective(OMPErrorDirective *D) {
2574	VisitStmt(D);
2575	// The NumClauses field was read in ReadStmtFromStream.
2576	Record.skipInts(N: 1);
2577	VisitOMPExecutableDirective(D);
2578	}
2579
2580	void ASTStmtReader::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
2581	VisitStmt(D);
2582	VisitOMPExecutableDirective(D);
2583	}
2584
2585	void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) {
2586	VisitStmt(D);
2587	VisitOMPExecutableDirective(D);
2588	}
2589
2590	void ASTStmtReader::VisitOMPDepobjDirective(OMPDepobjDirective *D) {
2591	VisitStmt(D);
2592	VisitOMPExecutableDirective(D);
2593	}
2594
2595	void ASTStmtReader::VisitOMPScanDirective(OMPScanDirective *D) {
2596	VisitStmt(D);
2597	VisitOMPExecutableDirective(D);
2598	}
2599
2600	void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
2601	VisitStmt(D);
2602	VisitOMPExecutableDirective(D);
2603	}
2604
2605	void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
2606	VisitStmt(D);
2607	VisitOMPExecutableDirective(D);
2608	D->Flags.IsXLHSInRHSPart = Record.readBool() ? 1 : 0;
2609	D->Flags.IsPostfixUpdate = Record.readBool() ? 1 : 0;
2610	D->Flags.IsFailOnly = Record.readBool() ? 1 : 0;
2611	}
2612
2613	void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) {
2614	VisitStmt(D);
2615	VisitOMPExecutableDirective(D);
2616	}
2617
2618	void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
2619	VisitStmt(D);
2620	VisitOMPExecutableDirective(D);
2621	}
2622
2623	void ASTStmtReader::VisitOMPTargetEnterDataDirective(
2624	OMPTargetEnterDataDirective *D) {
2625	VisitStmt(D);
2626	VisitOMPExecutableDirective(D);
2627	}
2628
2629	void ASTStmtReader::VisitOMPTargetExitDataDirective(
2630	OMPTargetExitDataDirective *D) {
2631	VisitStmt(D);
2632	VisitOMPExecutableDirective(D);
2633	}
2634
2635	void ASTStmtReader::VisitOMPTargetParallelDirective(
2636	OMPTargetParallelDirective *D) {
2637	VisitStmt(D);
2638	VisitOMPExecutableDirective(D);
2639	D->setHasCancel(Record.readBool());
2640	}
2641
2642	void ASTStmtReader::VisitOMPTargetParallelForDirective(
2643	OMPTargetParallelForDirective *D) {
2644	VisitOMPLoopDirective(D);
2645	D->setHasCancel(Record.readBool());
2646	}
2647
2648	void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2649	VisitStmt(D);
2650	VisitOMPExecutableDirective(D);
2651	}
2652
2653	void ASTStmtReader::VisitOMPCancellationPointDirective(
2654	OMPCancellationPointDirective *D) {
2655	VisitStmt(D);
2656	VisitOMPExecutableDirective(D);
2657	D->setCancelRegion(Record.readEnum<OpenMPDirectiveKind>());
2658	}
2659
2660	void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) {
2661	VisitStmt(D);
2662	VisitOMPExecutableDirective(D);
2663	D->setCancelRegion(Record.readEnum<OpenMPDirectiveKind>());
2664	}
2665
2666	void ASTStmtReader::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
2667	VisitOMPLoopDirective(D);
2668	D->setHasCancel(Record.readBool());
2669	}
2670
2671	void ASTStmtReader::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
2672	VisitOMPLoopDirective(D);
2673	}
2674
2675	void ASTStmtReader::VisitOMPMasterTaskLoopDirective(
2676	OMPMasterTaskLoopDirective *D) {
2677	VisitOMPLoopDirective(D);
2678	D->setHasCancel(Record.readBool());
2679	}
2680
2681	void ASTStmtReader::VisitOMPMaskedTaskLoopDirective(
2682	OMPMaskedTaskLoopDirective *D) {
2683	VisitOMPLoopDirective(D);
2684	D->setHasCancel(Record.readBool());
2685	}
2686
2687	void ASTStmtReader::VisitOMPMasterTaskLoopSimdDirective(
2688	OMPMasterTaskLoopSimdDirective *D) {
2689	VisitOMPLoopDirective(D);
2690	}
2691
2692	void ASTStmtReader::VisitOMPMaskedTaskLoopSimdDirective(
2693	OMPMaskedTaskLoopSimdDirective *D) {
2694	VisitOMPLoopDirective(D);
2695	}
2696
2697	void ASTStmtReader::VisitOMPParallelMasterTaskLoopDirective(
2698	OMPParallelMasterTaskLoopDirective *D) {
2699	VisitOMPLoopDirective(D);
2700	D->setHasCancel(Record.readBool());
2701	}
2702
2703	void ASTStmtReader::VisitOMPParallelMaskedTaskLoopDirective(
2704	OMPParallelMaskedTaskLoopDirective *D) {
2705	VisitOMPLoopDirective(D);
2706	D->setHasCancel(Record.readBool());
2707	}
2708
2709	void ASTStmtReader::VisitOMPParallelMasterTaskLoopSimdDirective(
2710	OMPParallelMasterTaskLoopSimdDirective *D) {
2711	VisitOMPLoopDirective(D);
2712	}
2713
2714	void ASTStmtReader::VisitOMPParallelMaskedTaskLoopSimdDirective(
2715	OMPParallelMaskedTaskLoopSimdDirective *D) {
2716	VisitOMPLoopDirective(D);
2717	}
2718
2719	void ASTStmtReader::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
2720	VisitOMPLoopDirective(D);
2721	}
2722
2723	void ASTStmtReader::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) {
2724	VisitStmt(D);
2725	VisitOMPExecutableDirective(D);
2726	}
2727
2728	void ASTStmtReader::VisitOMPDistributeParallelForDirective(
2729	OMPDistributeParallelForDirective *D) {
2730	VisitOMPLoopDirective(D);
2731	D->setHasCancel(Record.readBool());
2732	}
2733
2734	void ASTStmtReader::VisitOMPDistributeParallelForSimdDirective(
2735	OMPDistributeParallelForSimdDirective *D) {
2736	VisitOMPLoopDirective(D);
2737	}
2738
2739	void ASTStmtReader::VisitOMPDistributeSimdDirective(
2740	OMPDistributeSimdDirective *D) {
2741	VisitOMPLoopDirective(D);
2742	}
2743
2744	void ASTStmtReader::VisitOMPTargetParallelForSimdDirective(
2745	OMPTargetParallelForSimdDirective *D) {
2746	VisitOMPLoopDirective(D);
2747	}
2748
2749	void ASTStmtReader::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) {
2750	VisitOMPLoopDirective(D);
2751	}
2752
2753	void ASTStmtReader::VisitOMPTeamsDistributeDirective(
2754	OMPTeamsDistributeDirective *D) {
2755	VisitOMPLoopDirective(D);
2756	}
2757
2758	void ASTStmtReader::VisitOMPTeamsDistributeSimdDirective(
2759	OMPTeamsDistributeSimdDirective *D) {
2760	VisitOMPLoopDirective(D);
2761	}
2762
2763	void ASTStmtReader::VisitOMPTeamsDistributeParallelForSimdDirective(
2764	OMPTeamsDistributeParallelForSimdDirective *D) {
2765	VisitOMPLoopDirective(D);
2766	}
2767
2768	void ASTStmtReader::VisitOMPTeamsDistributeParallelForDirective(
2769	OMPTeamsDistributeParallelForDirective *D) {
2770	VisitOMPLoopDirective(D);
2771	D->setHasCancel(Record.readBool());
2772	}
2773
2774	void ASTStmtReader::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) {
2775	VisitStmt(D);
2776	VisitOMPExecutableDirective(D);
2777	}
2778
2779	void ASTStmtReader::VisitOMPTargetTeamsDistributeDirective(
2780	OMPTargetTeamsDistributeDirective *D) {
2781	VisitOMPLoopDirective(D);
2782	}
2783
2784	void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForDirective(
2785	OMPTargetTeamsDistributeParallelForDirective *D) {
2786	VisitOMPLoopDirective(D);
2787	D->setHasCancel(Record.readBool());
2788	}
2789
2790	void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
2791	OMPTargetTeamsDistributeParallelForSimdDirective *D) {
2792	VisitOMPLoopDirective(D);
2793	}
2794
2795	void ASTStmtReader::VisitOMPTargetTeamsDistributeSimdDirective(
2796	OMPTargetTeamsDistributeSimdDirective *D) {
2797	VisitOMPLoopDirective(D);
2798	}
2799
2800	void ASTStmtReader::VisitOMPInteropDirective(OMPInteropDirective *D) {
2801	VisitStmt(D);
2802	VisitOMPExecutableDirective(D);
2803	}
2804
2805	void ASTStmtReader::VisitOMPDispatchDirective(OMPDispatchDirective *D) {
2806	VisitStmt(D);
2807	VisitOMPExecutableDirective(D);
2808	D->setTargetCallLoc(Record.readSourceLocation());
2809	}
2810
2811	void ASTStmtReader::VisitOMPMaskedDirective(OMPMaskedDirective *D) {
2812	VisitStmt(D);
2813	VisitOMPExecutableDirective(D);
2814	}
2815
2816	void ASTStmtReader::VisitOMPGenericLoopDirective(OMPGenericLoopDirective *D) {
2817	VisitOMPLoopDirective(D);
2818	}
2819
2820	void ASTStmtReader::VisitOMPTeamsGenericLoopDirective(
2821	OMPTeamsGenericLoopDirective *D) {
2822	VisitOMPLoopDirective(D);
2823	}
2824
2825	void ASTStmtReader::VisitOMPTargetTeamsGenericLoopDirective(
2826	OMPTargetTeamsGenericLoopDirective *D) {
2827	VisitOMPLoopDirective(D);
2828	D->setCanBeParallelFor(Record.readBool());
2829	}
2830
2831	void ASTStmtReader::VisitOMPParallelGenericLoopDirective(
2832	OMPParallelGenericLoopDirective *D) {
2833	VisitOMPLoopDirective(D);
2834	}
2835
2836	void ASTStmtReader::VisitOMPTargetParallelGenericLoopDirective(
2837	OMPTargetParallelGenericLoopDirective *D) {
2838	VisitOMPLoopDirective(D);
2839	}
2840
2841	//===----------------------------------------------------------------------===//
2842	// OpenACC Constructs/Directives.
2843	//===----------------------------------------------------------------------===//
2844	void ASTStmtReader::VisitOpenACCConstructStmt(OpenACCConstructStmt *S) {
2845	(void)Record.readInt();
2846	S->Kind = Record.readEnum<OpenACCDirectiveKind>();
2847	S->Range = Record.readSourceRange();
2848	S->DirectiveLoc = Record.readSourceLocation();
2849	Record.readOpenACCClauseList(Clauses: S->Clauses);
2850	}
2851
2852	void ASTStmtReader::VisitOpenACCAssociatedStmtConstruct(
2853	OpenACCAssociatedStmtConstruct *S) {
2854	VisitOpenACCConstructStmt(S);
2855	S->setAssociatedStmt(Record.readSubStmt());
2856	}
2857
2858	void ASTStmtReader::VisitOpenACCComputeConstruct(OpenACCComputeConstruct *S) {
2859	VisitStmt(S);
2860	VisitOpenACCAssociatedStmtConstruct(S);
2861	}
2862
2863	void ASTStmtReader::VisitOpenACCLoopConstruct(OpenACCLoopConstruct *S) {
2864	VisitStmt(S);
2865	VisitOpenACCAssociatedStmtConstruct(S);
2866	S->ParentComputeConstructKind = Record.readEnum<OpenACCDirectiveKind>();
2867	}
2868
2869	void ASTStmtReader::VisitOpenACCCombinedConstruct(OpenACCCombinedConstruct *S) {
2870	VisitStmt(S);
2871	VisitOpenACCAssociatedStmtConstruct(S);
2872	}
2873
2874	void ASTStmtReader::VisitOpenACCDataConstruct(OpenACCDataConstruct *S) {
2875	VisitStmt(S);
2876	VisitOpenACCAssociatedStmtConstruct(S);
2877	}
2878
2879	void ASTStmtReader::VisitOpenACCEnterDataConstruct(
2880	OpenACCEnterDataConstruct *S) {
2881	VisitStmt(S);
2882	VisitOpenACCConstructStmt(S);
2883	}
2884
2885	void ASTStmtReader::VisitOpenACCExitDataConstruct(OpenACCExitDataConstruct *S) {
2886	VisitStmt(S);
2887	VisitOpenACCConstructStmt(S);
2888	}
2889
2890	void ASTStmtReader::VisitOpenACCInitConstruct(OpenACCInitConstruct *S) {
2891	VisitStmt(S);
2892	VisitOpenACCConstructStmt(S);
2893	}
2894
2895	void ASTStmtReader::VisitOpenACCShutdownConstruct(OpenACCShutdownConstruct *S) {
2896	VisitStmt(S);
2897	VisitOpenACCConstructStmt(S);
2898	}
2899
2900	void ASTStmtReader::VisitOpenACCSetConstruct(OpenACCSetConstruct *S) {
2901	VisitStmt(S);
2902	VisitOpenACCConstructStmt(S);
2903	}
2904
2905	void ASTStmtReader::VisitOpenACCUpdateConstruct(OpenACCUpdateConstruct *S) {
2906	VisitStmt(S);
2907	VisitOpenACCConstructStmt(S);
2908	}
2909
2910	void ASTStmtReader::VisitOpenACCHostDataConstruct(OpenACCHostDataConstruct *S) {
2911	VisitStmt(S);
2912	VisitOpenACCAssociatedStmtConstruct(S);
2913	}
2914
2915	void ASTStmtReader::VisitOpenACCWaitConstruct(OpenACCWaitConstruct *S) {
2916	VisitStmt(S);
2917	// Consume the count of Expressions.
2918	(void)Record.readInt();
2919	VisitOpenACCConstructStmt(S);
2920	S->LParenLoc = Record.readSourceLocation();
2921	S->RParenLoc = Record.readSourceLocation();
2922	S->QueuesLoc = Record.readSourceLocation();
2923
2924	for (unsigned I = 0; I < S->NumExprs; ++I) {
2925	S->getExprPtr()[I] = cast_if_present<Expr>(Val: Record.readSubStmt());
2926	assert((I == 0 || S->getExprPtr()[I] != nullptr) &&
2927	"Only first expression should be null");
2928	}
2929	}
2930
2931	void ASTStmtReader::VisitOpenACCCacheConstruct(OpenACCCacheConstruct *S) {
2932	VisitStmt(S);
2933	(void)Record.readInt();
2934	VisitOpenACCConstructStmt(S);
2935	S->ParensLoc = Record.readSourceRange();
2936	S->ReadOnlyLoc = Record.readSourceLocation();
2937	for (unsigned I = 0; I < S->NumVars; ++I)
2938	S->getVarList()[I] = cast<Expr>(Val: Record.readSubStmt());
2939	}
2940
2941	void ASTStmtReader::VisitOpenACCAtomicConstruct(OpenACCAtomicConstruct *S) {
2942	VisitStmt(S);
2943	VisitOpenACCConstructStmt(S);
2944	S->AtomicKind = Record.readEnum<OpenACCAtomicKind>();
2945	S->setAssociatedStmt(Record.readSubStmt());
2946	}
2947
2948	//===----------------------------------------------------------------------===//
2949	// HLSL Constructs/Directives.
2950	//===----------------------------------------------------------------------===//
2951
2952	void ASTStmtReader::VisitHLSLOutArgExpr(HLSLOutArgExpr *S) {
2953	VisitExpr(S);
2954	S->SubExprs[HLSLOutArgExpr::BaseLValue] = Record.readSubExpr();
2955	S->SubExprs[HLSLOutArgExpr::CastedTemporary] = Record.readSubExpr();
2956	S->SubExprs[HLSLOutArgExpr::WritebackCast] = Record.readSubExpr();
2957	S->IsInOut = Record.readBool();
2958	}
2959
2960	//===----------------------------------------------------------------------===//
2961	// ASTReader Implementation
2962	//===----------------------------------------------------------------------===//
2963
2964	Stmt *ASTReader::ReadStmt(ModuleFile &F) {
2965	switch (ReadingKind) {
2966	case Read_None:
2967	llvm_unreachable("should not call this when not reading anything");
2968	case Read_Decl:
2969	case Read_Type:
2970	return ReadStmtFromStream(F);
2971	case Read_Stmt:
2972	return ReadSubStmt();
2973	}
2974
2975	llvm_unreachable("ReadingKind not set ?");
2976	}
2977
2978	Expr *ASTReader::ReadExpr(ModuleFile &F) {
2979	return cast_or_null<Expr>(Val: ReadStmt(F));
2980	}
2981
2982	Expr *ASTReader::ReadSubExpr() {
2983	return cast_or_null<Expr>(Val: ReadSubStmt());
2984	}
2985
2986	// Within the bitstream, expressions are stored in Reverse Polish
2987	// Notation, with each of the subexpressions preceding the
2988	// expression they are stored in. Subexpressions are stored from last to first.
2989	// To evaluate expressions, we continue reading expressions and placing them on
2990	// the stack, with expressions having operands removing those operands from the
2991	// stack. Evaluation terminates when we see a STMT_STOP record, and
2992	// the single remaining expression on the stack is our result.
2993	Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
2994	ReadingKindTracker ReadingKind(Read_Stmt, *this);
2995	llvm::BitstreamCursor &Cursor = F.DeclsCursor;
2996
2997	// Map of offset to previously deserialized stmt. The offset points
2998	// just after the stmt record.
2999	llvm::DenseMap<uint64_t, Stmt *> StmtEntries;
3000
3001	#ifndef NDEBUG
3002	unsigned PrevNumStmts = StmtStack.size();
3003	#endif
3004
3005	ASTRecordReader Record(*this, F);
3006	ASTStmtReader Reader(Record, Cursor);
3007	Stmt::EmptyShell Empty;
3008
3009	while (true) {
3010	llvm::Expected<llvm::BitstreamEntry> MaybeEntry =
3011	Cursor.advanceSkippingSubblocks();
3012	if (!MaybeEntry) {
3013	Error(Msg: toString(E: MaybeEntry.takeError()));
3014	return nullptr;
3015	}
3016	llvm::BitstreamEntry Entry = MaybeEntry.get();
3017
3018	switch (Entry.Kind) {
3019	case llvm::BitstreamEntry::SubBlock: // Handled for us already.
3020	case llvm::BitstreamEntry::Error:
3021	Error(Msg: "malformed block record in AST file");
3022	return nullptr;
3023	case llvm::BitstreamEntry::EndBlock:
3024	goto Done;
3025	case llvm::BitstreamEntry::Record:
3026	// The interesting case.
3027	break;
3028	}
3029
3030	ASTContext &Context = getContext();
3031	Stmt *S = nullptr;
3032	bool Finished = false;
3033	bool IsStmtReference = false;
3034	Expected<unsigned> MaybeStmtCode = Record.readRecord(Cursor, AbbrevID: Entry.ID);
3035	if (!MaybeStmtCode) {
3036	Error(Msg: toString(E: MaybeStmtCode.takeError()));
3037	return nullptr;
3038	}
3039	switch ((StmtCode)MaybeStmtCode.get()) {
3040	case STMT_STOP:
3041	Finished = true;
3042	break;
3043
3044	case STMT_REF_PTR:
3045	IsStmtReference = true;
3046	assert(StmtEntries.contains(Record[0]) &&
3047	"No stmt was recorded for this offset reference!");
3048	S = StmtEntries[Record.readInt()];
3049	break;
3050
3051	case STMT_NULL_PTR:
3052	S = nullptr;
3053	break;
3054
3055	case STMT_NULL:
3056	S = new (Context) NullStmt(Empty);
3057	break;
3058
3059	case STMT_COMPOUND: {
3060	unsigned NumStmts = Record[ASTStmtReader::NumStmtFields];
3061	bool HasFPFeatures = Record[ASTStmtReader::NumStmtFields + 1];
3062	S = CompoundStmt::CreateEmpty(C: Context, NumStmts, HasFPFeatures);
3063	break;
3064	}
3065
3066	case STMT_CASE:
3067	S = CaseStmt::CreateEmpty(
3068	Ctx: Context,
3069	/*CaseStmtIsGNURange*/ Record[ASTStmtReader::NumStmtFields + 3]);
3070	break;
3071
3072	case STMT_DEFAULT:
3073	S = new (Context) DefaultStmt(Empty);
3074	break;
3075
3076	case STMT_LABEL:
3077	S = new (Context) LabelStmt(Empty);
3078	break;
3079
3080	case STMT_ATTRIBUTED:
3081	S = AttributedStmt::CreateEmpty(
3082	C: Context,
3083	/*NumAttrs*/Record[ASTStmtReader::NumStmtFields]);
3084	break;
3085
3086	case STMT_IF: {
3087	BitsUnpacker IfStmtBits(Record[ASTStmtReader::NumStmtFields]);
3088	bool HasElse = IfStmtBits.getNextBit();
3089	bool HasVar = IfStmtBits.getNextBit();
3090	bool HasInit = IfStmtBits.getNextBit();
3091	S = IfStmt::CreateEmpty(Ctx: Context, HasElse, HasVar, HasInit);
3092	break;
3093	}
3094
3095	case STMT_SWITCH:
3096	S = SwitchStmt::CreateEmpty(
3097	Ctx: Context,
3098	/* HasInit=*/Record[ASTStmtReader::NumStmtFields],
3099	/* HasVar=*/Record[ASTStmtReader::NumStmtFields + 1]);
3100	break;
3101
3102	case STMT_WHILE:
3103	S = WhileStmt::CreateEmpty(
3104	Ctx: Context,
3105	/* HasVar=*/Record[ASTStmtReader::NumStmtFields]);
3106	break;
3107
3108	case STMT_DO:
3109	S = new (Context) DoStmt(Empty);
3110	break;
3111
3112	case STMT_FOR:
3113	S = new (Context) ForStmt(Empty);
3114	break;
3115
3116	case STMT_GOTO:
3117	S = new (Context) GotoStmt(Empty);
3118	break;
3119
3120	case STMT_INDIRECT_GOTO:
3121	S = new (Context) IndirectGotoStmt(Empty);
3122	break;
3123
3124	case STMT_CONTINUE:
3125	S = new (Context) ContinueStmt(Empty);
3126	break;
3127
3128	case STMT_BREAK:
3129	S = new (Context) BreakStmt(Empty);
3130	break;
3131
3132	case STMT_RETURN:
3133	S = ReturnStmt::CreateEmpty(
3134	Ctx: Context, /* HasNRVOCandidate=*/Record[ASTStmtReader::NumStmtFields]);
3135	break;
3136
3137	case STMT_DECL:
3138	S = new (Context) DeclStmt(Empty);
3139	break;
3140
3141	case STMT_GCCASM:
3142	S = new (Context) GCCAsmStmt(Empty);
3143	break;
3144
3145	case STMT_MSASM:
3146	S = new (Context) MSAsmStmt(Empty);
3147	break;
3148
3149	case STMT_CAPTURED:
3150	S = CapturedStmt::CreateDeserialized(
3151	Context, NumCaptures: Record[ASTStmtReader::NumStmtFields]);
3152	break;
3153
3154	case STMT_SYCLKERNELCALL:
3155	S = new (Context) SYCLKernelCallStmt(Empty);
3156	break;
3157
3158	case EXPR_CONSTANT:
3159	S = ConstantExpr::CreateEmpty(
3160	Context, StorageKind: static_cast<ConstantResultStorageKind>(
3161	/*StorageKind=*/Record[ASTStmtReader::NumExprFields]));
3162	break;
3163
3164	case EXPR_SYCL_UNIQUE_STABLE_NAME:
3165	S = SYCLUniqueStableNameExpr::CreateEmpty(Ctx: Context);
3166	break;
3167
3168	case EXPR_OPENACC_ASTERISK_SIZE:
3169	S = OpenACCAsteriskSizeExpr::CreateEmpty(C: Context);
3170	break;
3171
3172	case EXPR_PREDEFINED:
3173	S = PredefinedExpr::CreateEmpty(
3174	Ctx: Context,
3175	/*HasFunctionName*/ Record[ASTStmtReader::NumExprFields]);
3176	break;
3177
3178	case EXPR_DECL_REF: {
3179	BitsUnpacker DeclRefExprBits(Record[ASTStmtReader::NumExprFields]);
3180	DeclRefExprBits.advance(BitsWidth: 5);
3181	bool HasFoundDecl = DeclRefExprBits.getNextBit();
3182	bool HasQualifier = DeclRefExprBits.getNextBit();
3183	bool HasTemplateKWAndArgsInfo = DeclRefExprBits.getNextBit();
3184	unsigned NumTemplateArgs = HasTemplateKWAndArgsInfo
3185	? Record[ASTStmtReader::NumExprFields + 1]
3186	: 0;
3187	S = DeclRefExpr::CreateEmpty(Context, HasQualifier, HasFoundDecl,
3188	HasTemplateKWAndArgsInfo, NumTemplateArgs);
3189	break;
3190	}
3191
3192	case EXPR_INTEGER_LITERAL:
3193	S = IntegerLiteral::Create(C: Context, Empty);
3194	break;
3195
3196	case EXPR_FIXEDPOINT_LITERAL:
3197	S = FixedPointLiteral::Create(C: Context, Empty);
3198	break;
3199
3200	case EXPR_FLOATING_LITERAL:
3201	S = FloatingLiteral::Create(C: Context, Empty);
3202	break;
3203
3204	case EXPR_IMAGINARY_LITERAL:
3205	S = new (Context) ImaginaryLiteral(Empty);
3206	break;
3207
3208	case EXPR_STRING_LITERAL:
3209	S = StringLiteral::CreateEmpty(
3210	Ctx: Context,
3211	/* NumConcatenated=*/Record[ASTStmtReader::NumExprFields],
3212	/* Length=*/Record[ASTStmtReader::NumExprFields + 1],
3213	/* CharByteWidth=*/Record[ASTStmtReader::NumExprFields + 2]);
3214	break;
3215
3216	case EXPR_CHARACTER_LITERAL:
3217	S = new (Context) CharacterLiteral(Empty);
3218	break;
3219
3220	case EXPR_PAREN:
3221	S = new (Context) ParenExpr(Empty);
3222	break;
3223
3224	case EXPR_PAREN_LIST:
3225	S = ParenListExpr::CreateEmpty(
3226	Ctx: Context,
3227	/* NumExprs=*/Record[ASTStmtReader::NumExprFields]);
3228	break;
3229
3230	case EXPR_UNARY_OPERATOR: {
3231	BitsUnpacker UnaryOperatorBits(Record[ASTStmtReader::NumStmtFields]);
3232	UnaryOperatorBits.advance(BitsWidth: ASTStmtReader::NumExprBits);
3233	bool HasFPFeatures = UnaryOperatorBits.getNextBit();
3234	S = UnaryOperator::CreateEmpty(C: Context, hasFPFeatures: HasFPFeatures);
3235	break;
3236	}
3237
3238	case EXPR_OFFSETOF:
3239	S = OffsetOfExpr::CreateEmpty(C: Context,
3240	NumComps: Record[ASTStmtReader::NumExprFields],
3241	NumExprs: Record[ASTStmtReader::NumExprFields + 1]);
3242	break;
3243
3244	case EXPR_SIZEOF_ALIGN_OF:
3245	S = new (Context) UnaryExprOrTypeTraitExpr(Empty);
3246	break;
3247
3248	case EXPR_ARRAY_SUBSCRIPT:
3249	S = new (Context) ArraySubscriptExpr(Empty);
3250	break;
3251
3252	case EXPR_MATRIX_SUBSCRIPT:
3253	S = new (Context) MatrixSubscriptExpr(Empty);
3254	break;
3255
3256	case EXPR_ARRAY_SECTION:
3257	S = new (Context) ArraySectionExpr(Empty);
3258	break;
3259
3260	case EXPR_OMP_ARRAY_SHAPING:
3261	S = OMPArrayShapingExpr::CreateEmpty(
3262	Context, NumDims: Record[ASTStmtReader::NumExprFields]);
3263	break;
3264
3265	case EXPR_OMP_ITERATOR:
3266	S = OMPIteratorExpr::CreateEmpty(Context,
3267	NumIterators: Record[ASTStmtReader::NumExprFields]);
3268	break;
3269
3270	case EXPR_CALL: {
3271	auto NumArgs = Record[ASTStmtReader::NumExprFields];
3272	BitsUnpacker CallExprBits(Record[ASTStmtReader::NumExprFields + 1]);
3273	CallExprBits.advance(BitsWidth: 1);
3274	auto HasFPFeatures = CallExprBits.getNextBit();
3275	S = CallExpr::CreateEmpty(Ctx: Context, NumArgs, HasFPFeatures, Empty);
3276	break;
3277	}
3278
3279	case EXPR_RECOVERY:
3280	S = RecoveryExpr::CreateEmpty(
3281	Ctx&: Context, /*NumArgs=*/NumSubExprs: Record[ASTStmtReader::NumExprFields]);
3282	break;
3283
3284	case EXPR_MEMBER: {
3285	BitsUnpacker ExprMemberBits(Record[ASTStmtReader::NumExprFields]);
3286	bool HasQualifier = ExprMemberBits.getNextBit();
3287	bool HasFoundDecl = ExprMemberBits.getNextBit();
3288	bool HasTemplateInfo = ExprMemberBits.getNextBit();
3289	unsigned NumTemplateArgs = Record[ASTStmtReader::NumExprFields + 1];
3290	S = MemberExpr::CreateEmpty(Context, HasQualifier, HasFoundDecl,
3291	HasTemplateKWAndArgsInfo: HasTemplateInfo, NumTemplateArgs);
3292	break;
3293	}
3294
3295	case EXPR_BINARY_OPERATOR: {
3296	BitsUnpacker BinaryOperatorBits(Record[ASTStmtReader::NumExprFields]);
3297	BinaryOperatorBits.advance(/*Size of opcode*/ BitsWidth: 6);
3298	bool HasFPFeatures = BinaryOperatorBits.getNextBit();
3299	S = BinaryOperator::CreateEmpty(C: Context, hasFPFeatures: HasFPFeatures);
3300	break;
3301	}
3302
3303	case EXPR_COMPOUND_ASSIGN_OPERATOR: {
3304	BitsUnpacker BinaryOperatorBits(Record[ASTStmtReader::NumExprFields]);
3305	BinaryOperatorBits.advance(/*Size of opcode*/ BitsWidth: 6);
3306	bool HasFPFeatures = BinaryOperatorBits.getNextBit();
3307	S = CompoundAssignOperator::CreateEmpty(C: Context, hasFPFeatures: HasFPFeatures);
3308	break;
3309	}
3310
3311	case EXPR_CONDITIONAL_OPERATOR:
3312	S = new (Context) ConditionalOperator(Empty);
3313	break;
3314
3315	case EXPR_BINARY_CONDITIONAL_OPERATOR:
3316	S = new (Context) BinaryConditionalOperator(Empty);
3317	break;
3318
3319	case EXPR_IMPLICIT_CAST: {
3320	unsigned PathSize = Record[ASTStmtReader::NumExprFields];
3321	BitsUnpacker CastExprBits(Record[ASTStmtReader::NumExprFields + 1]);
3322	CastExprBits.advance(BitsWidth: 7);
3323	bool HasFPFeatures = CastExprBits.getNextBit();
3324	S = ImplicitCastExpr::CreateEmpty(Context, PathSize, HasFPFeatures);
3325	break;
3326	}
3327
3328	case EXPR_CSTYLE_CAST: {
3329	unsigned PathSize = Record[ASTStmtReader::NumExprFields];
3330	BitsUnpacker CastExprBits(Record[ASTStmtReader::NumExprFields + 1]);
3331	CastExprBits.advance(BitsWidth: 7);
3332	bool HasFPFeatures = CastExprBits.getNextBit();
3333	S = CStyleCastExpr::CreateEmpty(Context, PathSize, HasFPFeatures);
3334	break;
3335	}
3336
3337	case EXPR_COMPOUND_LITERAL:
3338	S = new (Context) CompoundLiteralExpr(Empty);
3339	break;
3340
3341	case EXPR_EXT_VECTOR_ELEMENT:
3342	S = new (Context) ExtVectorElementExpr(Empty);
3343	break;
3344
3345	case EXPR_INIT_LIST:
3346	S = new (Context) InitListExpr(Empty);
3347	break;
3348
3349	case EXPR_DESIGNATED_INIT:
3350	S = DesignatedInitExpr::CreateEmpty(C: Context,
3351	NumIndexExprs: Record[ASTStmtReader::NumExprFields] - 1);
3352
3353	break;
3354
3355	case EXPR_DESIGNATED_INIT_UPDATE:
3356	S = new (Context) DesignatedInitUpdateExpr(Empty);
3357	break;
3358
3359	case EXPR_IMPLICIT_VALUE_INIT:
3360	S = new (Context) ImplicitValueInitExpr(Empty);
3361	break;
3362
3363	case EXPR_NO_INIT:
3364	S = new (Context) NoInitExpr(Empty);
3365	break;
3366
3367	case EXPR_ARRAY_INIT_LOOP:
3368	S = new (Context) ArrayInitLoopExpr(Empty);
3369	break;
3370
3371	case EXPR_ARRAY_INIT_INDEX:
3372	S = new (Context) ArrayInitIndexExpr(Empty);
3373	break;
3374
3375	case EXPR_VA_ARG:
3376	S = new (Context) VAArgExpr(Empty);
3377	break;
3378
3379	case EXPR_SOURCE_LOC:
3380	S = new (Context) SourceLocExpr(Empty);
3381	break;
3382
3383	case EXPR_BUILTIN_PP_EMBED:
3384	S = new (Context) EmbedExpr(Empty);
3385	break;
3386
3387	case EXPR_ADDR_LABEL:
3388	S = new (Context) AddrLabelExpr(Empty);
3389	break;
3390
3391	case EXPR_STMT:
3392	S = new (Context) StmtExpr(Empty);
3393	break;
3394
3395	case EXPR_CHOOSE:
3396	S = new (Context) ChooseExpr(Empty);
3397	break;
3398
3399	case EXPR_GNU_NULL:
3400	S = new (Context) GNUNullExpr(Empty);
3401	break;
3402
3403	case EXPR_SHUFFLE_VECTOR:
3404	S = new (Context) ShuffleVectorExpr(Empty);
3405	break;
3406
3407	case EXPR_CONVERT_VECTOR: {
3408	BitsUnpacker ConvertVectorExprBits(Record[ASTStmtReader::NumStmtFields]);
3409	ConvertVectorExprBits.advance(BitsWidth: ASTStmtReader::NumExprBits);
3410	bool HasFPFeatures = ConvertVectorExprBits.getNextBit();
3411	S = ConvertVectorExpr::CreateEmpty(C: Context, hasFPFeatures: HasFPFeatures);
3412	break;
3413	}
3414
3415	case EXPR_BLOCK:
3416	S = new (Context) BlockExpr(Empty);
3417	break;
3418
3419	case EXPR_GENERIC_SELECTION:
3420	S = GenericSelectionExpr::CreateEmpty(
3421	Context,
3422	/*NumAssocs=*/Record[ASTStmtReader::NumExprFields]);
3423	break;
3424
3425	case EXPR_OBJC_STRING_LITERAL:
3426	S = new (Context) ObjCStringLiteral(Empty);
3427	break;
3428
3429	case EXPR_OBJC_BOXED_EXPRESSION:
3430	S = new (Context) ObjCBoxedExpr(Empty);
3431	break;
3432
3433	case EXPR_OBJC_ARRAY_LITERAL:
3434	S = ObjCArrayLiteral::CreateEmpty(C: Context,
3435	NumElements: Record[ASTStmtReader::NumExprFields]);
3436	break;
3437
3438	case EXPR_OBJC_DICTIONARY_LITERAL:
3439	S = ObjCDictionaryLiteral::CreateEmpty(C: Context,
3440	NumElements: Record[ASTStmtReader::NumExprFields],
3441	HasPackExpansions: Record[ASTStmtReader::NumExprFields + 1]);
3442	break;
3443
3444	case EXPR_OBJC_ENCODE:
3445	S = new (Context) ObjCEncodeExpr(Empty);
3446	break;
3447
3448	case EXPR_OBJC_SELECTOR_EXPR:
3449	S = new (Context) ObjCSelectorExpr(Empty);
3450	break;
3451
3452	case EXPR_OBJC_PROTOCOL_EXPR:
3453	S = new (Context) ObjCProtocolExpr(Empty);
3454	break;
3455
3456	case EXPR_OBJC_IVAR_REF_EXPR:
3457	S = new (Context) ObjCIvarRefExpr(Empty);
3458	break;
3459
3460	case EXPR_OBJC_PROPERTY_REF_EXPR:
3461	S = new (Context) ObjCPropertyRefExpr(Empty);
3462	break;
3463
3464	case EXPR_OBJC_SUBSCRIPT_REF_EXPR:
3465	S = new (Context) ObjCSubscriptRefExpr(Empty);
3466	break;
3467
3468	case EXPR_OBJC_KVC_REF_EXPR:
3469	llvm_unreachable("mismatching AST file");
3470
3471	case EXPR_OBJC_MESSAGE_EXPR:
3472	S = ObjCMessageExpr::CreateEmpty(Context,
3473	NumArgs: Record[ASTStmtReader::NumExprFields],
3474	NumStoredSelLocs: Record[ASTStmtReader::NumExprFields + 1]);
3475	break;
3476
3477	case EXPR_OBJC_ISA:
3478	S = new (Context) ObjCIsaExpr(Empty);
3479	break;
3480
3481	case EXPR_OBJC_INDIRECT_COPY_RESTORE:
3482	S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);
3483	break;
3484
3485	case EXPR_OBJC_BRIDGED_CAST:
3486	S = new (Context) ObjCBridgedCastExpr(Empty);
3487	break;
3488
3489	case STMT_OBJC_FOR_COLLECTION:
3490	S = new (Context) ObjCForCollectionStmt(Empty);
3491	break;
3492
3493	case STMT_OBJC_CATCH:
3494	S = new (Context) ObjCAtCatchStmt(Empty);
3495	break;
3496
3497	case STMT_OBJC_FINALLY:
3498	S = new (Context) ObjCAtFinallyStmt(Empty);
3499	break;
3500
3501	case STMT_OBJC_AT_TRY:
3502	S = ObjCAtTryStmt::CreateEmpty(Context,
3503	NumCatchStmts: Record[ASTStmtReader::NumStmtFields],
3504	HasFinally: Record[ASTStmtReader::NumStmtFields + 1]);
3505	break;
3506
3507	case STMT_OBJC_AT_SYNCHRONIZED:
3508	S = new (Context) ObjCAtSynchronizedStmt(Empty);
3509	break;
3510
3511	case STMT_OBJC_AT_THROW:
3512	S = new (Context) ObjCAtThrowStmt(Empty);
3513	break;
3514
3515	case STMT_OBJC_AUTORELEASE_POOL:
3516	S = new (Context) ObjCAutoreleasePoolStmt(Empty);
3517	break;
3518
3519	case EXPR_OBJC_BOOL_LITERAL:
3520	S = new (Context) ObjCBoolLiteralExpr(Empty);
3521	break;
3522
3523	case EXPR_OBJC_AVAILABILITY_CHECK:
3524	S = new (Context) ObjCAvailabilityCheckExpr(Empty);
3525	break;
3526
3527	case STMT_SEH_LEAVE:
3528	S = new (Context) SEHLeaveStmt(Empty);
3529	break;
3530
3531	case STMT_SEH_EXCEPT:
3532	S = new (Context) SEHExceptStmt(Empty);
3533	break;
3534
3535	case STMT_SEH_FINALLY:
3536	S = new (Context) SEHFinallyStmt(Empty);
3537	break;
3538
3539	case STMT_SEH_TRY:
3540	S = new (Context) SEHTryStmt(Empty);
3541	break;
3542
3543	case STMT_CXX_CATCH:
3544	S = new (Context) CXXCatchStmt(Empty);
3545	break;
3546
3547	case STMT_CXX_TRY:
3548	S = CXXTryStmt::Create(C: Context, Empty,
3549	/*numHandlers=*/Record[ASTStmtReader::NumStmtFields]);
3550	break;
3551
3552	case STMT_CXX_FOR_RANGE:
3553	S = new (Context) CXXForRangeStmt(Empty);
3554	break;
3555
3556	case STMT_MS_DEPENDENT_EXISTS:
3557	S = new (Context) MSDependentExistsStmt(SourceLocation(), true,
3558	NestedNameSpecifierLoc(),
3559	DeclarationNameInfo(),
3560	nullptr);
3561	break;
3562
3563	case STMT_OMP_CANONICAL_LOOP:
3564	S = OMPCanonicalLoop::createEmpty(Ctx: Context);
3565	break;
3566
3567	case STMT_OMP_META_DIRECTIVE:
3568	S = OMPMetaDirective::CreateEmpty(
3569	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3570	break;
3571
3572	case STMT_OMP_PARALLEL_DIRECTIVE:
3573	S =
3574	OMPParallelDirective::CreateEmpty(C: Context,
3575	NumClauses: Record[ASTStmtReader::NumStmtFields],
3576	Empty);
3577	break;
3578
3579	case STMT_OMP_SIMD_DIRECTIVE: {
3580	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3581	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3582	S = OMPSimdDirective::CreateEmpty(C: Context, NumClauses,
3583	CollapsedNum, Empty);
3584	break;
3585	}
3586
3587	case STMT_OMP_TILE_DIRECTIVE: {
3588	unsigned NumLoops = Record[ASTStmtReader::NumStmtFields];
3589	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3590	S = OMPTileDirective::CreateEmpty(C: Context, NumClauses, NumLoops);
3591	break;
3592	}
3593
3594	case STMP_OMP_STRIPE_DIRECTIVE: {
3595	unsigned NumLoops = Record[ASTStmtReader::NumStmtFields];
3596	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3597	S = OMPStripeDirective::CreateEmpty(C: Context, NumClauses, NumLoops);
3598	break;
3599	}
3600
3601	case STMT_OMP_UNROLL_DIRECTIVE: {
3602	assert(Record[ASTStmtReader::NumStmtFields] == 1 && "Unroll directive accepts only a single loop");
3603	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3604	S = OMPUnrollDirective::CreateEmpty(C: Context, NumClauses);
3605	break;
3606	}
3607
3608	case STMT_OMP_REVERSE_DIRECTIVE: {
3609	assert(Record[ASTStmtReader::NumStmtFields] == 1 &&
3610	"Reverse directive accepts only a single loop");
3611	assert(Record[ASTStmtReader::NumStmtFields + 1] == 0 &&
3612	"Reverse directive has no clauses");
3613	S = OMPReverseDirective::CreateEmpty(C: Context);
3614	break;
3615	}
3616
3617	case STMT_OMP_INTERCHANGE_DIRECTIVE: {
3618	unsigned NumLoops = Record[ASTStmtReader::NumStmtFields];
3619	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3620	S = OMPInterchangeDirective::CreateEmpty(C: Context, NumClauses, NumLoops);
3621	break;
3622	}
3623
3624	case STMT_OMP_FOR_DIRECTIVE: {
3625	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3626	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3627	S = OMPForDirective::CreateEmpty(C: Context, NumClauses, CollapsedNum,
3628	Empty);
3629	break;
3630	}
3631
3632	case STMT_OMP_FOR_SIMD_DIRECTIVE: {
3633	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3634	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3635	S = OMPForSimdDirective::CreateEmpty(C: Context, NumClauses, CollapsedNum,
3636	Empty);
3637	break;
3638	}
3639
3640	case STMT_OMP_SECTIONS_DIRECTIVE:
3641	S = OMPSectionsDirective::CreateEmpty(
3642	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3643	break;
3644
3645	case STMT_OMP_SECTION_DIRECTIVE:
3646	S = OMPSectionDirective::CreateEmpty(C: Context, Empty);
3647	break;
3648
3649	case STMT_OMP_SCOPE_DIRECTIVE:
3650	S = OMPScopeDirective::CreateEmpty(
3651	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3652	break;
3653
3654	case STMT_OMP_SINGLE_DIRECTIVE:
3655	S = OMPSingleDirective::CreateEmpty(
3656	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3657	break;
3658
3659	case STMT_OMP_MASTER_DIRECTIVE:
3660	S = OMPMasterDirective::CreateEmpty(C: Context, Empty);
3661	break;
3662
3663	case STMT_OMP_CRITICAL_DIRECTIVE:
3664	S = OMPCriticalDirective::CreateEmpty(
3665	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3666	break;
3667
3668	case STMT_OMP_PARALLEL_FOR_DIRECTIVE: {
3669	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3670	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3671	S = OMPParallelForDirective::CreateEmpty(C: Context, NumClauses,
3672	CollapsedNum, Empty);
3673	break;
3674	}
3675
3676	case STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE: {
3677	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3678	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3679	S = OMPParallelForSimdDirective::CreateEmpty(C: Context, NumClauses,
3680	CollapsedNum, Empty);
3681	break;
3682	}
3683
3684	case STMT_OMP_PARALLEL_MASTER_DIRECTIVE:
3685	S = OMPParallelMasterDirective::CreateEmpty(
3686	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3687	break;
3688
3689	case STMT_OMP_PARALLEL_MASKED_DIRECTIVE:
3690	S = OMPParallelMaskedDirective::CreateEmpty(
3691	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3692	break;
3693
3694	case STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE:
3695	S = OMPParallelSectionsDirective::CreateEmpty(
3696	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3697	break;
3698
3699	case STMT_OMP_TASK_DIRECTIVE:
3700	S = OMPTaskDirective::CreateEmpty(
3701	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3702	break;
3703
3704	case STMT_OMP_TASKYIELD_DIRECTIVE:
3705	S = OMPTaskyieldDirective::CreateEmpty(C: Context, Empty);
3706	break;
3707
3708	case STMT_OMP_BARRIER_DIRECTIVE:
3709	S = OMPBarrierDirective::CreateEmpty(C: Context, Empty);
3710	break;
3711
3712	case STMT_OMP_TASKWAIT_DIRECTIVE:
3713	S = OMPTaskwaitDirective::CreateEmpty(
3714	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3715	break;
3716
3717	case STMT_OMP_ERROR_DIRECTIVE:
3718	S = OMPErrorDirective::CreateEmpty(
3719	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3720	break;
3721
3722	case STMT_OMP_TASKGROUP_DIRECTIVE:
3723	S = OMPTaskgroupDirective::CreateEmpty(
3724	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3725	break;
3726
3727	case STMT_OMP_FLUSH_DIRECTIVE:
3728	S = OMPFlushDirective::CreateEmpty(
3729	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3730	break;
3731
3732	case STMT_OMP_DEPOBJ_DIRECTIVE:
3733	S = OMPDepobjDirective::CreateEmpty(
3734	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3735	break;
3736
3737	case STMT_OMP_SCAN_DIRECTIVE:
3738	S = OMPScanDirective::CreateEmpty(
3739	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3740	break;
3741
3742	case STMT_OMP_ORDERED_DIRECTIVE: {
3743	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3744	bool HasAssociatedStmt = Record[ASTStmtReader::NumStmtFields + 2];
3745	S = OMPOrderedDirective::CreateEmpty(C: Context, NumClauses,
3746	IsStandalone: !HasAssociatedStmt, Empty);
3747	break;
3748	}
3749
3750	case STMT_OMP_ATOMIC_DIRECTIVE:
3751	S = OMPAtomicDirective::CreateEmpty(
3752	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3753	break;
3754
3755	case STMT_OMP_TARGET_DIRECTIVE:
3756	S = OMPTargetDirective::CreateEmpty(
3757	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3758	break;
3759
3760	case STMT_OMP_TARGET_DATA_DIRECTIVE:
3761	S = OMPTargetDataDirective::CreateEmpty(
3762	C: Context, N: Record[ASTStmtReader::NumStmtFields], Empty);
3763	break;
3764
3765	case STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE:
3766	S = OMPTargetEnterDataDirective::CreateEmpty(
3767	C: Context, N: Record[ASTStmtReader::NumStmtFields], Empty);
3768	break;
3769
3770	case STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE:
3771	S = OMPTargetExitDataDirective::CreateEmpty(
3772	C: Context, N: Record[ASTStmtReader::NumStmtFields], Empty);
3773	break;
3774
3775	case STMT_OMP_TARGET_PARALLEL_DIRECTIVE:
3776	S = OMPTargetParallelDirective::CreateEmpty(
3777	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3778	break;
3779
3780	case STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE: {
3781	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3782	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3783	S = OMPTargetParallelForDirective::CreateEmpty(C: Context, NumClauses,
3784	CollapsedNum, Empty);
3785	break;
3786	}
3787
3788	case STMT_OMP_TARGET_UPDATE_DIRECTIVE:
3789	S = OMPTargetUpdateDirective::CreateEmpty(
3790	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3791	break;
3792
3793	case STMT_OMP_TEAMS_DIRECTIVE:
3794	S = OMPTeamsDirective::CreateEmpty(
3795	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3796	break;
3797
3798	case STMT_OMP_CANCELLATION_POINT_DIRECTIVE:
3799	S = OMPCancellationPointDirective::CreateEmpty(C: Context, Empty);
3800	break;
3801
3802	case STMT_OMP_CANCEL_DIRECTIVE:
3803	S = OMPCancelDirective::CreateEmpty(
3804	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3805	break;
3806
3807	case STMT_OMP_TASKLOOP_DIRECTIVE: {
3808	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3809	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3810	S = OMPTaskLoopDirective::CreateEmpty(C: Context, NumClauses, CollapsedNum,
3811	Empty);
3812	break;
3813	}
3814
3815	case STMT_OMP_TASKLOOP_SIMD_DIRECTIVE: {
3816	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3817	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3818	S = OMPTaskLoopSimdDirective::CreateEmpty(C: Context, NumClauses,
3819	CollapsedNum, Empty);
3820	break;
3821	}
3822
3823	case STMT_OMP_MASTER_TASKLOOP_DIRECTIVE: {
3824	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3825	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3826	S = OMPMasterTaskLoopDirective::CreateEmpty(C: Context, NumClauses,
3827	CollapsedNum, Empty);
3828	break;
3829	}
3830
3831	case STMT_OMP_MASKED_TASKLOOP_DIRECTIVE: {
3832	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3833	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3834	S = OMPMaskedTaskLoopDirective::CreateEmpty(C: Context, NumClauses,
3835	CollapsedNum, Empty);
3836	break;
3837	}
3838
3839	case STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE: {
3840	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3841	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3842	S = OMPMasterTaskLoopSimdDirective::CreateEmpty(C: Context, NumClauses,
3843	CollapsedNum, Empty);
3844	break;
3845	}
3846
3847	case STMT_OMP_MASKED_TASKLOOP_SIMD_DIRECTIVE: {
3848	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3849	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3850	S = OMPMaskedTaskLoopSimdDirective::CreateEmpty(C: Context, NumClauses,
3851	CollapsedNum, Empty);
3852	break;
3853	}
3854
3855	case STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE: {
3856	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3857	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3858	S = OMPParallelMasterTaskLoopDirective::CreateEmpty(C: Context, NumClauses,
3859	CollapsedNum, Empty);
3860	break;
3861	}
3862
3863	case STMT_OMP_PARALLEL_MASKED_TASKLOOP_DIRECTIVE: {
3864	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3865	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3866	S = OMPParallelMaskedTaskLoopDirective::CreateEmpty(C: Context, NumClauses,
3867	CollapsedNum, Empty);
3868	break;
3869	}
3870
3871	case STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE: {
3872	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3873	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3874	S = OMPParallelMasterTaskLoopSimdDirective::CreateEmpty(
3875	C: Context, NumClauses, CollapsedNum, Empty);
3876	break;
3877	}
3878
3879	case STMT_OMP_PARALLEL_MASKED_TASKLOOP_SIMD_DIRECTIVE: {
3880	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3881	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3882	S = OMPParallelMaskedTaskLoopSimdDirective::CreateEmpty(
3883	C: Context, NumClauses, CollapsedNum, Empty);
3884	break;
3885	}
3886
3887	case STMT_OMP_DISTRIBUTE_DIRECTIVE: {
3888	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3889	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3890	S = OMPDistributeDirective::CreateEmpty(C: Context, NumClauses, CollapsedNum,
3891	Empty);
3892	break;
3893	}
3894
3895	case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
3896	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3897	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3898	S = OMPDistributeParallelForDirective::CreateEmpty(C: Context, NumClauses,
3899	CollapsedNum, Empty);
3900	break;
3901	}
3902
3903	case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
3904	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3905	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3906	S = OMPDistributeParallelForSimdDirective::CreateEmpty(C: Context, NumClauses,
3907	CollapsedNum,
3908	Empty);
3909	break;
3910	}
3911
3912	case STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE: {
3913	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3914	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3915	S = OMPDistributeSimdDirective::CreateEmpty(C: Context, NumClauses,
3916	CollapsedNum, Empty);
3917	break;
3918	}
3919
3920	case STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE: {
3921	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3922	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3923	S = OMPTargetParallelForSimdDirective::CreateEmpty(C: Context, NumClauses,
3924	CollapsedNum, Empty);
3925	break;
3926	}
3927
3928	case STMT_OMP_TARGET_SIMD_DIRECTIVE: {
3929	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3930	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3931	S = OMPTargetSimdDirective::CreateEmpty(C: Context, NumClauses, CollapsedNum,
3932	Empty);
3933	break;
3934	}
3935
3936	case STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE: {
3937	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3938	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3939	S = OMPTeamsDistributeDirective::CreateEmpty(C: Context, NumClauses,
3940	CollapsedNum, Empty);
3941	break;
3942	}
3943
3944	case STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: {
3945	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3946	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3947	S = OMPTeamsDistributeSimdDirective::CreateEmpty(C: Context, NumClauses,
3948	CollapsedNum, Empty);
3949	break;
3950	}
3951
3952	case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
3953	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3954	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3955	S = OMPTeamsDistributeParallelForSimdDirective::CreateEmpty(
3956	C: Context, NumClauses, CollapsedNum, Empty);
3957	break;
3958	}
3959
3960	case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
3961	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3962	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3963	S = OMPTeamsDistributeParallelForDirective::CreateEmpty(
3964	C: Context, NumClauses, CollapsedNum, Empty);
3965	break;
3966	}
3967
3968	case STMT_OMP_TARGET_TEAMS_DIRECTIVE:
3969	S = OMPTargetTeamsDirective::CreateEmpty(
3970	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
3971	break;
3972
3973	case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE: {
3974	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3975	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3976	S = OMPTargetTeamsDistributeDirective::CreateEmpty(C: Context, NumClauses,
3977	CollapsedNum, Empty);
3978	break;
3979	}
3980
3981	case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
3982	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3983	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3984	S = OMPTargetTeamsDistributeParallelForDirective::CreateEmpty(
3985	C: Context, NumClauses, CollapsedNum, Empty);
3986	break;
3987	}
3988
3989	case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
3990	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3991	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3992	S = OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty(
3993	C: Context, NumClauses, CollapsedNum, Empty);
3994	break;
3995	}
3996
3997	case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: {
3998	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3999	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4000	S = OMPTargetTeamsDistributeSimdDirective::CreateEmpty(
4001	C: Context, NumClauses, CollapsedNum, Empty);
4002	break;
4003	}
4004
4005	case STMT_OMP_INTEROP_DIRECTIVE:
4006	S = OMPInteropDirective::CreateEmpty(
4007	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
4008	break;
4009
4010	case STMT_OMP_DISPATCH_DIRECTIVE:
4011	S = OMPDispatchDirective::CreateEmpty(
4012	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
4013	break;
4014
4015	case STMT_OMP_MASKED_DIRECTIVE:
4016	S = OMPMaskedDirective::CreateEmpty(
4017	C: Context, NumClauses: Record[ASTStmtReader::NumStmtFields], Empty);
4018	break;
4019
4020	case STMT_OMP_GENERIC_LOOP_DIRECTIVE: {
4021	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4022	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4023	S = OMPGenericLoopDirective::CreateEmpty(C: Context, NumClauses,
4024	CollapsedNum, Empty);
4025	break;
4026	}
4027
4028	case STMT_OMP_TEAMS_GENERIC_LOOP_DIRECTIVE: {
4029	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4030	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4031	S = OMPTeamsGenericLoopDirective::CreateEmpty(C: Context, NumClauses,
4032	CollapsedNum, Empty);
4033	break;
4034	}
4035
4036	case STMT_OMP_TARGET_TEAMS_GENERIC_LOOP_DIRECTIVE: {
4037	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4038	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4039	S = OMPTargetTeamsGenericLoopDirective::CreateEmpty(C: Context, NumClauses,
4040	CollapsedNum, Empty);
4041	break;
4042	}
4043
4044	case STMT_OMP_PARALLEL_GENERIC_LOOP_DIRECTIVE: {
4045	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4046	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4047	S = OMPParallelGenericLoopDirective::CreateEmpty(C: Context, NumClauses,
4048	CollapsedNum, Empty);
4049	break;
4050	}
4051
4052	case STMT_OMP_TARGET_PARALLEL_GENERIC_LOOP_DIRECTIVE: {
4053	unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
4054	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4055	S = OMPTargetParallelGenericLoopDirective::CreateEmpty(
4056	C: Context, NumClauses, CollapsedNum, Empty);
4057	break;
4058	}
4059
4060	case STMT_OMP_ASSUME_DIRECTIVE: {
4061	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4062	S = OMPAssumeDirective::CreateEmpty(C: Context, NumClauses, Empty);
4063	break;
4064	}
4065
4066	case EXPR_CXX_OPERATOR_CALL: {
4067	auto NumArgs = Record[ASTStmtReader::NumExprFields];
4068	BitsUnpacker CallExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4069	CallExprBits.advance(BitsWidth: 1);
4070	auto HasFPFeatures = CallExprBits.getNextBit();
4071	S = CXXOperatorCallExpr::CreateEmpty(Ctx: Context, NumArgs, HasFPFeatures,
4072	Empty);
4073	break;
4074	}
4075
4076	case EXPR_CXX_MEMBER_CALL: {
4077	auto NumArgs = Record[ASTStmtReader::NumExprFields];
4078	BitsUnpacker CallExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4079	CallExprBits.advance(BitsWidth: 1);
4080	auto HasFPFeatures = CallExprBits.getNextBit();
4081	S = CXXMemberCallExpr::CreateEmpty(Ctx: Context, NumArgs, HasFPFeatures,
4082	Empty);
4083	break;
4084	}
4085
4086	case EXPR_CXX_REWRITTEN_BINARY_OPERATOR:
4087	S = new (Context) CXXRewrittenBinaryOperator(Empty);
4088	break;
4089
4090	case EXPR_CXX_CONSTRUCT:
4091	S = CXXConstructExpr::CreateEmpty(
4092	Ctx: Context,
4093	/* NumArgs=*/Record[ASTStmtReader::NumExprFields]);
4094	break;
4095
4096	case EXPR_CXX_INHERITED_CTOR_INIT:
4097	S = new (Context) CXXInheritedCtorInitExpr(Empty);
4098	break;
4099
4100	case EXPR_CXX_TEMPORARY_OBJECT:
4101	S = CXXTemporaryObjectExpr::CreateEmpty(
4102	Ctx: Context,
4103	/* NumArgs=*/Record[ASTStmtReader::NumExprFields]);
4104	break;
4105
4106	case EXPR_CXX_STATIC_CAST: {
4107	unsigned PathSize = Record[ASTStmtReader::NumExprFields];
4108	BitsUnpacker CastExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4109	CastExprBits.advance(BitsWidth: 7);
4110	bool HasFPFeatures = CastExprBits.getNextBit();
4111	S = CXXStaticCastExpr::CreateEmpty(Context, PathSize, hasFPFeatures: HasFPFeatures);
4112	break;
4113	}
4114
4115	case EXPR_CXX_DYNAMIC_CAST: {
4116	unsigned PathSize = Record[ASTStmtReader::NumExprFields];
4117	S = CXXDynamicCastExpr::CreateEmpty(Context, pathSize: PathSize);
4118	break;
4119	}
4120
4121	case EXPR_CXX_REINTERPRET_CAST: {
4122	unsigned PathSize = Record[ASTStmtReader::NumExprFields];
4123	S = CXXReinterpretCastExpr::CreateEmpty(Context, pathSize: PathSize);
4124	break;
4125	}
4126
4127	case EXPR_CXX_CONST_CAST:
4128	S = CXXConstCastExpr::CreateEmpty(Context);
4129	break;
4130
4131	case EXPR_CXX_ADDRSPACE_CAST:
4132	S = CXXAddrspaceCastExpr::CreateEmpty(Context);
4133	break;
4134
4135	case EXPR_CXX_FUNCTIONAL_CAST: {
4136	unsigned PathSize = Record[ASTStmtReader::NumExprFields];
4137	BitsUnpacker CastExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4138	CastExprBits.advance(BitsWidth: 7);
4139	bool HasFPFeatures = CastExprBits.getNextBit();
4140	S = CXXFunctionalCastExpr::CreateEmpty(Context, PathSize, HasFPFeatures);
4141	break;
4142	}
4143
4144	case EXPR_BUILTIN_BIT_CAST: {
4145	#ifndef NDEBUG
4146	unsigned PathSize = Record[ASTStmtReader::NumExprFields];
4147	assert(PathSize == 0 && "Wrong PathSize!");
4148	#endif
4149	S = new (Context) BuiltinBitCastExpr(Empty);
4150	break;
4151	}
4152
4153	case EXPR_USER_DEFINED_LITERAL: {
4154	auto NumArgs = Record[ASTStmtReader::NumExprFields];
4155	BitsUnpacker CallExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4156	CallExprBits.advance(BitsWidth: 1);
4157	auto HasFPFeatures = CallExprBits.getNextBit();
4158	S = UserDefinedLiteral::CreateEmpty(Ctx: Context, NumArgs, HasFPOptions: HasFPFeatures,
4159	Empty);
4160	break;
4161	}
4162
4163	case EXPR_CXX_STD_INITIALIZER_LIST:
4164	S = new (Context) CXXStdInitializerListExpr(Empty);
4165	break;
4166
4167	case EXPR_CXX_BOOL_LITERAL:
4168	S = new (Context) CXXBoolLiteralExpr(Empty);
4169	break;
4170
4171	case EXPR_CXX_NULL_PTR_LITERAL:
4172	S = new (Context) CXXNullPtrLiteralExpr(Empty);
4173	break;
4174
4175	case EXPR_CXX_TYPEID_EXPR:
4176	S = new (Context) CXXTypeidExpr(Empty, true);
4177	break;
4178
4179	case EXPR_CXX_TYPEID_TYPE:
4180	S = new (Context) CXXTypeidExpr(Empty, false);
4181	break;
4182
4183	case EXPR_CXX_UUIDOF_EXPR:
4184	S = new (Context) CXXUuidofExpr(Empty, true);
4185	break;
4186
4187	case EXPR_CXX_PROPERTY_REF_EXPR:
4188	S = new (Context) MSPropertyRefExpr(Empty);
4189	break;
4190
4191	case EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR:
4192	S = new (Context) MSPropertySubscriptExpr(Empty);
4193	break;
4194
4195	case EXPR_CXX_UUIDOF_TYPE:
4196	S = new (Context) CXXUuidofExpr(Empty, false);
4197	break;
4198
4199	case EXPR_CXX_THIS:
4200	S = CXXThisExpr::CreateEmpty(Ctx: Context);
4201	break;
4202
4203	case EXPR_CXX_THROW:
4204	S = new (Context) CXXThrowExpr(Empty);
4205	break;
4206
4207	case EXPR_CXX_DEFAULT_ARG:
4208	S = CXXDefaultArgExpr::CreateEmpty(
4209	C: Context, /*HasRewrittenInit=*/Record[ASTStmtReader::NumExprFields]);
4210	break;
4211
4212	case EXPR_CXX_DEFAULT_INIT:
4213	S = CXXDefaultInitExpr::CreateEmpty(
4214	C: Context, /*HasRewrittenInit=*/Record[ASTStmtReader::NumExprFields]);
4215	break;
4216
4217	case EXPR_CXX_BIND_TEMPORARY:
4218	S = new (Context) CXXBindTemporaryExpr(Empty);
4219	break;
4220
4221	case EXPR_CXX_SCALAR_VALUE_INIT:
4222	S = new (Context) CXXScalarValueInitExpr(Empty);
4223	break;
4224
4225	case EXPR_CXX_NEW:
4226	S = CXXNewExpr::CreateEmpty(
4227	Ctx: Context,
4228	/*IsArray=*/Record[ASTStmtReader::NumExprFields],
4229	/*HasInit=*/Record[ASTStmtReader::NumExprFields + 1],
4230	/*NumPlacementArgs=*/Record[ASTStmtReader::NumExprFields + 2],
4231	/*IsParenTypeId=*/Record[ASTStmtReader::NumExprFields + 3]);
4232	break;
4233
4234	case EXPR_CXX_DELETE:
4235	S = new (Context) CXXDeleteExpr(Empty);
4236	break;
4237
4238	case EXPR_CXX_PSEUDO_DESTRUCTOR:
4239	S = new (Context) CXXPseudoDestructorExpr(Empty);
4240	break;
4241
4242	case EXPR_EXPR_WITH_CLEANUPS:
4243	S = ExprWithCleanups::Create(C: Context, empty: Empty,
4244	numObjects: Record[ASTStmtReader::NumExprFields]);
4245	break;
4246
4247	case EXPR_CXX_DEPENDENT_SCOPE_MEMBER: {
4248	unsigned NumTemplateArgs = Record[ASTStmtReader::NumExprFields];
4249	BitsUnpacker DependentScopeMemberBits(
4250	Record[ASTStmtReader::NumExprFields + 1]);
4251	bool HasTemplateKWAndArgsInfo = DependentScopeMemberBits.getNextBit();
4252
4253	bool HasFirstQualifierFoundInScope =
4254	DependentScopeMemberBits.getNextBit();
4255	S = CXXDependentScopeMemberExpr::CreateEmpty(
4256	Ctx: Context, HasTemplateKWAndArgsInfo, NumTemplateArgs,
4257	HasFirstQualifierFoundInScope);
4258	break;
4259	}
4260
4261	case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF: {
4262	BitsUnpacker DependentScopeDeclRefBits(
4263	Record[ASTStmtReader::NumStmtFields]);
4264	DependentScopeDeclRefBits.advance(BitsWidth: ASTStmtReader::NumExprBits);
4265	bool HasTemplateKWAndArgsInfo = DependentScopeDeclRefBits.getNextBit();
4266	unsigned NumTemplateArgs =
4267	HasTemplateKWAndArgsInfo
4268	? DependentScopeDeclRefBits.getNextBits(/*Width=*/16)
4269	: 0;
4270	S = DependentScopeDeclRefExpr::CreateEmpty(
4271	Context, HasTemplateKWAndArgsInfo, NumTemplateArgs);
4272	break;
4273	}
4274
4275	case EXPR_CXX_UNRESOLVED_CONSTRUCT:
4276	S = CXXUnresolvedConstructExpr::CreateEmpty(Context,
4277	/*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
4278	break;
4279
4280	case EXPR_CXX_UNRESOLVED_MEMBER: {
4281	auto NumResults = Record[ASTStmtReader::NumExprFields];
4282	BitsUnpacker OverloadExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4283	auto HasTemplateKWAndArgsInfo = OverloadExprBits.getNextBit();
4284	auto NumTemplateArgs = HasTemplateKWAndArgsInfo
4285	? Record[ASTStmtReader::NumExprFields + 2]
4286	: 0;
4287	S = UnresolvedMemberExpr::CreateEmpty(
4288	Context, NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);
4289	break;
4290	}
4291
4292	case EXPR_CXX_UNRESOLVED_LOOKUP: {
4293	auto NumResults = Record[ASTStmtReader::NumExprFields];
4294	BitsUnpacker OverloadExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4295	auto HasTemplateKWAndArgsInfo = OverloadExprBits.getNextBit();
4296	auto NumTemplateArgs = HasTemplateKWAndArgsInfo
4297	? Record[ASTStmtReader::NumExprFields + 2]
4298	: 0;
4299	S = UnresolvedLookupExpr::CreateEmpty(
4300	Context, NumResults, HasTemplateKWAndArgsInfo, NumTemplateArgs);
4301	break;
4302	}
4303
4304	case EXPR_TYPE_TRAIT:
4305	S = TypeTraitExpr::CreateDeserialized(
4306	C: Context, IsStoredAsBool: Record[ASTStmtReader::NumExprFields],
4307	NumArgs: Record[ASTStmtReader::NumExprFields + 1]);
4308	break;
4309
4310	case EXPR_ARRAY_TYPE_TRAIT:
4311	S = new (Context) ArrayTypeTraitExpr(Empty);
4312	break;
4313
4314	case EXPR_CXX_EXPRESSION_TRAIT:
4315	S = new (Context) ExpressionTraitExpr(Empty);
4316	break;
4317
4318	case EXPR_CXX_NOEXCEPT:
4319	S = new (Context) CXXNoexceptExpr(Empty);
4320	break;
4321
4322	case EXPR_PACK_EXPANSION:
4323	S = new (Context) PackExpansionExpr(Empty);
4324	break;
4325
4326	case EXPR_SIZEOF_PACK:
4327	S = SizeOfPackExpr::CreateDeserialized(
4328	Context,
4329	/*NumPartialArgs=*/Record[ASTStmtReader::NumExprFields]);
4330	break;
4331
4332	case EXPR_PACK_INDEXING:
4333	S = PackIndexingExpr::CreateDeserialized(
4334	Context,
4335	/*TransformedExprs=*/NumTransformedExprs: Record[ASTStmtReader::NumExprFields]);
4336	break;
4337
4338	case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM:
4339	S = new (Context) SubstNonTypeTemplateParmExpr(Empty);
4340	break;
4341
4342	case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK:
4343	S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
4344	break;
4345
4346	case EXPR_FUNCTION_PARM_PACK:
4347	S = FunctionParmPackExpr::CreateEmpty(Context,
4348	NumParams: Record[ASTStmtReader::NumExprFields]);
4349	break;
4350
4351	case EXPR_MATERIALIZE_TEMPORARY:
4352	S = new (Context) MaterializeTemporaryExpr(Empty);
4353	break;
4354
4355	case EXPR_CXX_FOLD:
4356	S = new (Context) CXXFoldExpr(Empty);
4357	break;
4358
4359	case EXPR_CXX_PAREN_LIST_INIT:
4360	S = CXXParenListInitExpr::CreateEmpty(
4361	C&: Context, /*numExprs=*/Record[ASTStmtReader::NumExprFields], Empty);
4362	break;
4363
4364	case EXPR_OPAQUE_VALUE:
4365	S = new (Context) OpaqueValueExpr(Empty);
4366	break;
4367
4368	case EXPR_CUDA_KERNEL_CALL: {
4369	auto NumArgs = Record[ASTStmtReader::NumExprFields];
4370	BitsUnpacker CallExprBits(Record[ASTStmtReader::NumExprFields + 1]);
4371	CallExprBits.advance(BitsWidth: 1);
4372	auto HasFPFeatures = CallExprBits.getNextBit();
4373	S = CUDAKernelCallExpr::CreateEmpty(Ctx: Context, NumArgs, HasFPFeatures,
4374	Empty);
4375	break;
4376	}
4377
4378	case EXPR_ASTYPE:
4379	S = new (Context) AsTypeExpr(Empty);
4380	break;
4381
4382	case EXPR_PSEUDO_OBJECT: {
4383	unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields];
4384	S = PseudoObjectExpr::Create(Context, shell: Empty, numSemanticExprs);
4385	break;
4386	}
4387
4388	case EXPR_ATOMIC:
4389	S = new (Context) AtomicExpr(Empty);
4390	break;
4391
4392	case EXPR_LAMBDA: {
4393	unsigned NumCaptures = Record[ASTStmtReader::NumExprFields];
4394	S = LambdaExpr::CreateDeserialized(C: Context, NumCaptures);
4395	break;
4396	}
4397
4398	case STMT_COROUTINE_BODY: {
4399	unsigned NumParams = Record[ASTStmtReader::NumStmtFields];
4400	S = CoroutineBodyStmt::Create(C: Context, Empty, NumParams);
4401	break;
4402	}
4403
4404	case STMT_CORETURN:
4405	S = new (Context) CoreturnStmt(Empty);
4406	break;
4407
4408	case EXPR_COAWAIT:
4409	S = new (Context) CoawaitExpr(Empty);
4410	break;
4411
4412	case EXPR_COYIELD:
4413	S = new (Context) CoyieldExpr(Empty);
4414	break;
4415
4416	case EXPR_DEPENDENT_COAWAIT:
4417	S = new (Context) DependentCoawaitExpr(Empty);
4418	break;
4419
4420	case EXPR_CONCEPT_SPECIALIZATION: {
4421	S = new (Context) ConceptSpecializationExpr(Empty);
4422	break;
4423	}
4424	case STMT_OPENACC_COMPUTE_CONSTRUCT: {
4425	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4426	S = OpenACCComputeConstruct::CreateEmpty(C: Context, NumClauses);
4427	break;
4428	}
4429	case STMT_OPENACC_LOOP_CONSTRUCT: {
4430	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4431	S = OpenACCLoopConstruct::CreateEmpty(C: Context, NumClauses);
4432	break;
4433	}
4434	case STMT_OPENACC_COMBINED_CONSTRUCT: {
4435	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4436	S = OpenACCCombinedConstruct::CreateEmpty(C: Context, NumClauses);
4437	break;
4438	}
4439	case STMT_OPENACC_DATA_CONSTRUCT: {
4440	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4441	S = OpenACCDataConstruct::CreateEmpty(C: Context, NumClauses);
4442	break;
4443	}
4444	case STMT_OPENACC_ENTER_DATA_CONSTRUCT: {
4445	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4446	S = OpenACCEnterDataConstruct::CreateEmpty(C: Context, NumClauses);
4447	break;
4448	}
4449	case STMT_OPENACC_EXIT_DATA_CONSTRUCT: {
4450	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4451	S = OpenACCExitDataConstruct::CreateEmpty(C: Context, NumClauses);
4452	break;
4453	}
4454	case STMT_OPENACC_HOST_DATA_CONSTRUCT: {
4455	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4456	S = OpenACCHostDataConstruct::CreateEmpty(C: Context, NumClauses);
4457	break;
4458	}
4459	case STMT_OPENACC_WAIT_CONSTRUCT: {
4460	unsigned NumExprs = Record[ASTStmtReader::NumStmtFields];
4461	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
4462	S = OpenACCWaitConstruct::CreateEmpty(C: Context, NumExprs, NumClauses);
4463	break;
4464	}
4465	case STMT_OPENACC_CACHE_CONSTRUCT: {
4466	unsigned NumVars = Record[ASTStmtReader::NumStmtFields];
4467	S = OpenACCCacheConstruct::CreateEmpty(C: Context, NumVars);
4468	break;
4469	}
4470	case STMT_OPENACC_INIT_CONSTRUCT: {
4471	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4472	S = OpenACCInitConstruct::CreateEmpty(C: Context, NumClauses);
4473	break;
4474	}
4475	case STMT_OPENACC_SHUTDOWN_CONSTRUCT: {
4476	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4477	S = OpenACCShutdownConstruct::CreateEmpty(C: Context, NumClauses);
4478	break;
4479	}
4480	case STMT_OPENACC_SET_CONSTRUCT: {
4481	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4482	S = OpenACCSetConstruct::CreateEmpty(C: Context, NumClauses);
4483	break;
4484	}
4485	case STMT_OPENACC_UPDATE_CONSTRUCT: {
4486	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4487	S = OpenACCUpdateConstruct::CreateEmpty(C: Context, NumClauses);
4488	break;
4489	}
4490	case STMT_OPENACC_ATOMIC_CONSTRUCT: {
4491	unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
4492	S = OpenACCAtomicConstruct::CreateEmpty(C: Context, NumClauses);
4493	break;
4494	}
4495	case EXPR_REQUIRES: {
4496	unsigned numLocalParameters = Record[ASTStmtReader::NumExprFields];
4497	unsigned numRequirement = Record[ASTStmtReader::NumExprFields + 1];
4498	S = RequiresExpr::Create(C&: Context, Empty, NumLocalParameters: numLocalParameters,
4499	NumRequirements: numRequirement);
4500	break;
4501	}
4502	case EXPR_HLSL_OUT_ARG:
4503	S = HLSLOutArgExpr::CreateEmpty(Ctx: Context);
4504	break;
4505	}
4506
4507	// We hit a STMT_STOP, so we're done with this expression.
4508	if (Finished)
4509	break;
4510
4511	++NumStatementsRead;
4512
4513	if (S && !IsStmtReference) {
4514	Reader.Visit(S);
4515	StmtEntries[Cursor.GetCurrentBitNo()] = S;
4516	}
4517
4518	assert(Record.getIdx() == Record.size() &&
4519	"Invalid deserialization of statement");
4520	StmtStack.push_back(Elt: S);
4521	}
4522	Done:
4523	assert(StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!");
4524	assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
4525	return StmtStack.pop_back_val();
4526	}
4527