clang  16.0.0git
ASTReaderStmt.cpp
Go to the documentation of this file.
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"
19 #include "clang/AST/DeclCXX.h"
20 #include "clang/AST/DeclGroup.h"
21 #include "clang/AST/DeclObjC.h"
22 #include "clang/AST/DeclTemplate.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"
30 #include "clang/AST/OpenMPClause.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/StmtVisitor.h"
37 #include "clang/AST/TemplateBase.h"
38 #include "clang/AST/Type.h"
42 #include "clang/Basic/LLVM.h"
43 #include "clang/Basic/Lambda.h"
48 #include "clang/Basic/Specifiers.h"
49 #include "clang/Basic/TypeTraits.h"
50 #include "clang/Lex/Token.h"
53 #include "llvm/ADT/BitmaskEnum.h"
54 #include "llvm/ADT/DenseMap.h"
55 #include "llvm/ADT/SmallString.h"
56 #include "llvm/ADT/SmallVector.h"
57 #include "llvm/ADT/StringRef.h"
58 #include "llvm/Bitstream/BitstreamReader.h"
59 #include "llvm/Support/Casting.h"
60 #include "llvm/Support/ErrorHandling.h"
61 #include <algorithm>
62 #include <cassert>
63 #include <cstdint>
64 #include <string>
65 
66 using namespace clang;
67 using namespace serialization;
68 
69 namespace clang {
70 
71  class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
72  ASTRecordReader &Record;
73  llvm::BitstreamCursor &DeclsCursor;
74 
75  SourceLocation readSourceLocation() {
76  return Record.readSourceLocation();
77  }
78 
79  SourceRange readSourceRange() {
80  return Record.readSourceRange();
81  }
82 
83  std::string readString() {
84  return Record.readString();
85  }
86 
87  TypeSourceInfo *readTypeSourceInfo() {
88  return Record.readTypeSourceInfo();
89  }
90 
91  Decl *readDecl() {
92  return Record.readDecl();
93  }
94 
95  template<typename T>
96  T *readDeclAs() {
97  return Record.readDeclAs<T>();
98  }
99 
100  public:
101  ASTStmtReader(ASTRecordReader &Record, llvm::BitstreamCursor &Cursor)
102  : Record(Record), DeclsCursor(Cursor) {}
103 
104  /// The number of record fields required for the Stmt class
105  /// itself.
106  static const unsigned NumStmtFields = 0;
107 
108  /// The number of record fields required for the Expr class
109  /// itself.
110  static const unsigned NumExprFields = NumStmtFields + 4;
111 
112  /// Read and initialize a ExplicitTemplateArgumentList structure.
113  void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
114  TemplateArgumentLoc *ArgsLocArray,
115  unsigned NumTemplateArgs);
116 
117  /// Read and initialize a ExplicitTemplateArgumentList structure.
118  void ReadExplicitTemplateArgumentList(ASTTemplateArgumentListInfo &ArgList,
119  unsigned NumTemplateArgs);
120 
121  void VisitStmt(Stmt *S);
122 #define STMT(Type, Base) \
123  void Visit##Type(Type *);
124 #include "clang/AST/StmtNodes.inc"
125  };
126 
127 } // namespace clang
128 
130  TemplateArgumentLoc *ArgsLocArray,
131  unsigned NumTemplateArgs) {
132  SourceLocation TemplateKWLoc = readSourceLocation();
133  TemplateArgumentListInfo ArgInfo;
134  ArgInfo.setLAngleLoc(readSourceLocation());
135  ArgInfo.setRAngleLoc(readSourceLocation());
136  for (unsigned i = 0; i != NumTemplateArgs; ++i)
137  ArgInfo.addArgument(Record.readTemplateArgumentLoc());
138  Args.initializeFrom(TemplateKWLoc, ArgInfo, ArgsLocArray);
139 }
140 
142  assert(Record.getIdx() == NumStmtFields && "Incorrect statement field count");
143 }
144 
145 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
146  VisitStmt(S);
147  S->setSemiLoc(readSourceLocation());
148  S->NullStmtBits.HasLeadingEmptyMacro = Record.readInt();
149 }
150 
151 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
152  VisitStmt(S);
154  unsigned NumStmts = Record.readInt();
155  unsigned HasFPFeatures = Record.readInt();
156  assert(S->hasStoredFPFeatures() == HasFPFeatures);
157  while (NumStmts--)
158  Stmts.push_back(Record.readSubStmt());
159  S->setStmts(Stmts);
160  if (HasFPFeatures)
161  S->setStoredFPFeatures(
162  FPOptionsOverride::getFromOpaqueInt(Record.readInt()));
163  S->LBraceLoc = readSourceLocation();
164  S->RBraceLoc = readSourceLocation();
165 }
166 
167 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
168  VisitStmt(S);
169  Record.recordSwitchCaseID(S, Record.readInt());
170  S->setKeywordLoc(readSourceLocation());
171  S->setColonLoc(readSourceLocation());
172 }
173 
174 void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
175  VisitSwitchCase(S);
176  bool CaseStmtIsGNURange = Record.readInt();
177  S->setLHS(Record.readSubExpr());
178  S->setSubStmt(Record.readSubStmt());
179  if (CaseStmtIsGNURange) {
180  S->setRHS(Record.readSubExpr());
181  S->setEllipsisLoc(readSourceLocation());
182  }
183 }
184 
185 void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
186  VisitSwitchCase(S);
187  S->setSubStmt(Record.readSubStmt());
188 }
189 
190 void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
191  VisitStmt(S);
192  bool IsSideEntry = Record.readInt();
193  auto *LD = readDeclAs<LabelDecl>();
194  LD->setStmt(S);
195  S->setDecl(LD);
196  S->setSubStmt(Record.readSubStmt());
197  S->setIdentLoc(readSourceLocation());
198  S->setSideEntry(IsSideEntry);
199 }
200 
201 void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) {
202  VisitStmt(S);
203  // NumAttrs in AttributedStmt is set when creating an empty
204  // AttributedStmt in AttributedStmt::CreateEmpty, since it is needed
205  // to allocate the right amount of space for the trailing Attr *.
206  uint64_t NumAttrs = Record.readInt();
207  AttrVec Attrs;
208  Record.readAttributes(Attrs);
209  (void)NumAttrs;
210  assert(NumAttrs == S->AttributedStmtBits.NumAttrs);
211  assert(NumAttrs == Attrs.size());
212  std::copy(Attrs.begin(), Attrs.end(), S->getAttrArrayPtr());
213  S->SubStmt = Record.readSubStmt();
214  S->AttributedStmtBits.AttrLoc = readSourceLocation();
215 }
216 
217 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
218  VisitStmt(S);
219 
220  bool HasElse = Record.readInt();
221  bool HasVar = Record.readInt();
222  bool HasInit = Record.readInt();
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->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
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->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
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(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->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
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->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
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 {
355  int N = Record.size() - Record.getIdx();
356  Decls.reserve(N);
357  for (int I = 0; I < N; ++I)
358  Decls.push_back(readDecl());
359  S->setDeclGroup(DeclGroupRef(DeclGroup::Create(Record.getContext(),
360  Decls.data(),
361  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->setAsmString(cast_or_null<StringLiteral>(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
390  for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
391  Names.push_back(Record.readIdentifier());
392  Constraints.push_back(cast_or_null<StringLiteral>(Record.readSubStmt()));
393  Exprs.push_back(Record.readSubStmt());
394  }
395 
396  // Constraints
398  for (unsigned I = 0; I != NumClobbers; ++I)
399  Clobbers.push_back(cast_or_null<StringLiteral>(Record.readSubStmt()));
400 
401  // Labels
402  for (unsigned I = 0, N = NumLabels; I != N; ++I)
403  Exprs.push_back(Record.readSubStmt());
404 
405  S->setOutputsAndInputsAndClobbers(Record.getContext(),
406  Names.data(), Constraints.data(),
407  Exprs.data(), NumOutputs, NumInputs,
408  NumLabels,
409  Clobbers.data(), NumClobbers);
410 }
411 
412 void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) {
413  VisitAsmStmt(S);
414  S->LBraceLoc = readSourceLocation();
415  S->EndLoc = readSourceLocation();
416  S->NumAsmToks = Record.readInt();
417  std::string AsmStr = readString();
418 
419  // Read the tokens.
420  SmallVector<Token, 16> AsmToks;
421  AsmToks.reserve(S->NumAsmToks);
422  for (unsigned i = 0, e = S->NumAsmToks; i != e; ++i) {
423  AsmToks.push_back(Record.readToken());
424  }
425 
426  // The calls to reserve() for the FooData vectors are mandatory to
427  // prevent dead StringRefs in the Foo vectors.
428 
429  // Read the clobbers.
430  SmallVector<std::string, 16> ClobbersData;
432  ClobbersData.reserve(S->NumClobbers);
433  Clobbers.reserve(S->NumClobbers);
434  for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) {
435  ClobbersData.push_back(readString());
436  Clobbers.push_back(ClobbersData.back());
437  }
438 
439  // Read the operands.
440  unsigned NumOperands = S->NumOutputs + S->NumInputs;
442  SmallVector<std::string, 16> ConstraintsData;
443  SmallVector<StringRef, 16> Constraints;
444  Exprs.reserve(NumOperands);
445  ConstraintsData.reserve(NumOperands);
446  Constraints.reserve(NumOperands);
447  for (unsigned i = 0; i != NumOperands; ++i) {
448  Exprs.push_back(cast<Expr>(Record.readSubStmt()));
449  ConstraintsData.push_back(readString());
450  Constraints.push_back(ConstraintsData.back());
451  }
452 
453  S->initialize(Record.getContext(), AsmStr, AsmToks,
454  Constraints, Exprs, Clobbers);
455 }
456 
457 void ASTStmtReader::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
458  VisitStmt(S);
459  assert(Record.peekInt() == S->NumParams);
460  Record.skipInts(1);
461  auto *StoredStmts = S->getStoredStmts();
462  for (unsigned i = 0;
463  i < CoroutineBodyStmt::SubStmt::FirstParamMove + S->NumParams; ++i)
464  StoredStmts[i] = Record.readSubStmt();
465 }
466 
467 void ASTStmtReader::VisitCoreturnStmt(CoreturnStmt *S) {
468  VisitStmt(S);
469  S->CoreturnLoc = Record.readSourceLocation();
470  for (auto &SubStmt: S->SubStmts)
471  SubStmt = Record.readSubStmt();
472  S->IsImplicit = Record.readInt() != 0;
473 }
474 
475 void ASTStmtReader::VisitCoawaitExpr(CoawaitExpr *E) {
476  VisitExpr(E);
477  E->KeywordLoc = readSourceLocation();
478  for (auto &SubExpr: E->SubExprs)
479  SubExpr = Record.readSubStmt();
480  E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt());
481  E->setIsImplicit(Record.readInt() != 0);
482 }
483 
484 void ASTStmtReader::VisitCoyieldExpr(CoyieldExpr *E) {
485  VisitExpr(E);
486  E->KeywordLoc = readSourceLocation();
487  for (auto &SubExpr: E->SubExprs)
488  SubExpr = Record.readSubStmt();
489  E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt());
490 }
491 
492 void ASTStmtReader::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) {
493  VisitExpr(E);
494  E->KeywordLoc = readSourceLocation();
495  for (auto &SubExpr: E->SubExprs)
496  SubExpr = Record.readSubStmt();
497 }
498 
499 void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) {
500  VisitStmt(S);
501  Record.skipInts(1);
502  S->setCapturedDecl(readDeclAs<CapturedDecl>());
503  S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record.readInt()));
504  S->setCapturedRecordDecl(readDeclAs<RecordDecl>());
505 
506  // Capture inits
507  for (CapturedStmt::capture_init_iterator I = S->capture_init_begin(),
508  E = S->capture_init_end();
509  I != E; ++I)
510  *I = Record.readSubExpr();
511 
512  // Body
513  S->setCapturedStmt(Record.readSubStmt());
514  S->getCapturedDecl()->setBody(S->getCapturedStmt());
515 
516  // Captures
517  for (auto &I : S->captures()) {
518  I.VarAndKind.setPointer(readDeclAs<VarDecl>());
519  I.VarAndKind.setInt(
520  static_cast<CapturedStmt::VariableCaptureKind>(Record.readInt()));
521  I.Loc = readSourceLocation();
522  }
523 }
524 
525 void ASTStmtReader::VisitExpr(Expr *E) {
526  VisitStmt(E);
527  E->setType(Record.readType());
528  E->setDependence(static_cast<ExprDependence>(Record.readInt()));
529  E->setValueKind(static_cast<ExprValueKind>(Record.readInt()));
530  E->setObjectKind(static_cast<ExprObjectKind>(Record.readInt()));
531  assert(Record.getIdx() == NumExprFields &&
532  "Incorrect expression field count");
533 }
534 
535 void ASTStmtReader::VisitConstantExpr(ConstantExpr *E) {
536  VisitExpr(E);
537 
538  auto StorageKind = Record.readInt();
539  assert(E->ConstantExprBits.ResultKind == StorageKind && "Wrong ResultKind!");
540 
541  E->ConstantExprBits.APValueKind = Record.readInt();
542  E->ConstantExprBits.IsUnsigned = Record.readInt();
543  E->ConstantExprBits.BitWidth = Record.readInt();
544  E->ConstantExprBits.HasCleanup = false; // Not serialized, see below.
545  E->ConstantExprBits.IsImmediateInvocation = Record.readInt();
546 
547  switch (StorageKind) {
549  break;
550 
552  E->Int64Result() = Record.readInt();
553  break;
554 
556  E->APValueResult() = Record.readAPValue();
557  if (E->APValueResult().needsCleanup()) {
558  E->ConstantExprBits.HasCleanup = true;
559  Record.getContext().addDestruction(&E->APValueResult());
560  }
561  break;
562  default:
563  llvm_unreachable("unexpected ResultKind!");
564  }
565 
566  E->setSubExpr(Record.readSubExpr());
567 }
568 
569 void ASTStmtReader::VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E) {
570  VisitExpr(E);
571 
572  E->setLocation(readSourceLocation());
573  E->setLParenLocation(readSourceLocation());
574  E->setRParenLocation(readSourceLocation());
575 
576  E->setTypeSourceInfo(Record.readTypeSourceInfo());
577 }
578 
579 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
580  VisitExpr(E);
581  bool HasFunctionName = Record.readInt();
582  E->PredefinedExprBits.HasFunctionName = HasFunctionName;
583  E->PredefinedExprBits.Kind = Record.readInt();
584  E->setLocation(readSourceLocation());
585  if (HasFunctionName)
586  E->setFunctionName(cast<StringLiteral>(Record.readSubExpr()));
587 }
588 
589 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
590  VisitExpr(E);
591 
592  E->DeclRefExprBits.HasQualifier = Record.readInt();
593  E->DeclRefExprBits.HasFoundDecl = Record.readInt();
594  E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record.readInt();
595  E->DeclRefExprBits.HadMultipleCandidates = Record.readInt();
596  E->DeclRefExprBits.RefersToEnclosingVariableOrCapture = Record.readInt();
597  E->DeclRefExprBits.NonOdrUseReason = Record.readInt();
598  unsigned NumTemplateArgs = 0;
599  if (E->hasTemplateKWAndArgsInfo())
600  NumTemplateArgs = Record.readInt();
601 
602  if (E->hasQualifier())
603  new (E->getTrailingObjects<NestedNameSpecifierLoc>())
604  NestedNameSpecifierLoc(Record.readNestedNameSpecifierLoc());
605 
606  if (E->hasFoundDecl())
607  *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>();
608 
609  if (E->hasTemplateKWAndArgsInfo())
610  ReadTemplateKWAndArgsInfo(
611  *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
612  E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
613 
614  E->D = readDeclAs<ValueDecl>();
615  E->setLocation(readSourceLocation());
616  E->DNLoc = Record.readDeclarationNameLoc(E->getDecl()->getDeclName());
617 }
618 
619 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
620  VisitExpr(E);
621  E->setLocation(readSourceLocation());
622  E->setValue(Record.getContext(), Record.readAPInt());
623 }
624 
625 void ASTStmtReader::VisitFixedPointLiteral(FixedPointLiteral *E) {
626  VisitExpr(E);
627  E->setLocation(readSourceLocation());
628  E->setScale(Record.readInt());
629  E->setValue(Record.getContext(), Record.readAPInt());
630 }
631 
632 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
633  VisitExpr(E);
634  E->setRawSemantics(
635  static_cast<llvm::APFloatBase::Semantics>(Record.readInt()));
636  E->setExact(Record.readInt());
637  E->setValue(Record.getContext(), Record.readAPFloat(E->getSemantics()));
638  E->setLocation(readSourceLocation());
639 }
640 
641 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
642  VisitExpr(E);
643  E->setSubExpr(Record.readSubExpr());
644 }
645 
646 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
647  VisitExpr(E);
648 
649  // NumConcatenated, Length and CharByteWidth are set by the empty
650  // ctor since they are needed to allocate storage for the trailing objects.
651  unsigned NumConcatenated = Record.readInt();
652  unsigned Length = Record.readInt();
653  unsigned CharByteWidth = Record.readInt();
654  assert((NumConcatenated == E->getNumConcatenated()) &&
655  "Wrong number of concatenated tokens!");
656  assert((Length == E->getLength()) && "Wrong Length!");
657  assert((CharByteWidth == E->getCharByteWidth()) && "Wrong character width!");
658  E->StringLiteralBits.Kind = Record.readInt();
659  E->StringLiteralBits.IsPascal = Record.readInt();
660 
661  // The character width is originally computed via mapCharByteWidth.
662  // Check that the deserialized character width is consistant with the result
663  // of calling mapCharByteWidth.
664  assert((CharByteWidth ==
665  StringLiteral::mapCharByteWidth(Record.getContext().getTargetInfo(),
666  E->getKind())) &&
667  "Wrong character width!");
668 
669  // Deserialize the trailing array of SourceLocation.
670  for (unsigned I = 0; I < NumConcatenated; ++I)
671  E->setStrTokenLoc(I, readSourceLocation());
672 
673  // Deserialize the trailing array of char holding the string data.
674  char *StrData = E->getStrDataAsChar();
675  for (unsigned I = 0; I < Length * CharByteWidth; ++I)
676  StrData[I] = Record.readInt();
677 }
678 
679 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
680  VisitExpr(E);
681  E->setValue(Record.readInt());
682  E->setLocation(readSourceLocation());
683  E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record.readInt()));
684 }
685 
686 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
687  VisitExpr(E);
688  E->setLParen(readSourceLocation());
689  E->setRParen(readSourceLocation());
690  E->setSubExpr(Record.readSubExpr());
691 }
692 
693 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
694  VisitExpr(E);
695  unsigned NumExprs = Record.readInt();
696  assert((NumExprs == E->getNumExprs()) && "Wrong NumExprs!");
697  for (unsigned I = 0; I != NumExprs; ++I)
698  E->getTrailingObjects<Stmt *>()[I] = Record.readSubStmt();
699  E->LParenLoc = readSourceLocation();
700  E->RParenLoc = readSourceLocation();
701 }
702 
703 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
704  VisitExpr(E);
705  bool hasFP_Features = Record.readInt();
706  assert(hasFP_Features == E->hasStoredFPFeatures());
707  E->setSubExpr(Record.readSubExpr());
708  E->setOpcode((UnaryOperator::Opcode)Record.readInt());
709  E->setOperatorLoc(readSourceLocation());
710  E->setCanOverflow(Record.readInt());
711  if (hasFP_Features)
713  FPOptionsOverride::getFromOpaqueInt(Record.readInt()));
714 }
715 
716 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
717  VisitExpr(E);
718  assert(E->getNumComponents() == Record.peekInt());
719  Record.skipInts(1);
720  assert(E->getNumExpressions() == Record.peekInt());
721  Record.skipInts(1);
722  E->setOperatorLoc(readSourceLocation());
723  E->setRParenLoc(readSourceLocation());
724  E->setTypeSourceInfo(readTypeSourceInfo());
725  for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
726  auto Kind = static_cast<OffsetOfNode::Kind>(Record.readInt());
727  SourceLocation Start = readSourceLocation();
728  SourceLocation End = readSourceLocation();
729  switch (Kind) {
730  case OffsetOfNode::Array:
731  E->setComponent(I, OffsetOfNode(Start, Record.readInt(), End));
732  break;
733 
734  case OffsetOfNode::Field:
735  E->setComponent(
736  I, OffsetOfNode(Start, readDeclAs<FieldDecl>(), End));
737  break;
738 
740  E->setComponent(
741  I,
742  OffsetOfNode(Start, Record.readIdentifier(), End));
743  break;
744 
745  case OffsetOfNode::Base: {
746  auto *Base = new (Record.getContext()) CXXBaseSpecifier();
747  *Base = Record.readCXXBaseSpecifier();
749  break;
750  }
751  }
752  }
753 
754  for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
755  E->setIndexExpr(I, Record.readSubExpr());
756 }
757 
758 void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
759  VisitExpr(E);
760  E->setKind(static_cast<UnaryExprOrTypeTrait>(Record.readInt()));
761  if (Record.peekInt() == 0) {
762  E->setArgument(Record.readSubExpr());
763  Record.skipInts(1);
764  } else {
765  E->setArgument(readTypeSourceInfo());
766  }
767  E->setOperatorLoc(readSourceLocation());
768  E->setRParenLoc(readSourceLocation());
769 }
770 
773  ConstraintSatisfaction Satisfaction;
774  Satisfaction.IsSatisfied = Record.readInt();
775  Satisfaction.ContainsErrors = Record.readInt();
776  if (!Satisfaction.IsSatisfied) {
777  unsigned NumDetailRecords = Record.readInt();
778  for (unsigned i = 0; i != NumDetailRecords; ++i) {
779  Expr *ConstraintExpr = Record.readExpr();
780  if (/* IsDiagnostic */Record.readInt()) {
781  SourceLocation DiagLocation = Record.readSourceLocation();
782  std::string DiagMessage = Record.readString();
783  Satisfaction.Details.emplace_back(
784  ConstraintExpr, new (Record.getContext())
786  DiagLocation, DiagMessage});
787  } else
788  Satisfaction.Details.emplace_back(ConstraintExpr, Record.readExpr());
789  }
790  }
791  return Satisfaction;
792 }
793 
794 void ASTStmtReader::VisitConceptSpecializationExpr(
796  VisitExpr(E);
797  E->NestedNameSpec = Record.readNestedNameSpecifierLoc();
798  E->TemplateKWLoc = Record.readSourceLocation();
799  E->ConceptName = Record.readDeclarationNameInfo();
800  E->NamedConcept = readDeclAs<ConceptDecl>();
801  E->FoundDecl = Record.readDeclAs<NamedDecl>();
802  E->SpecDecl = Record.readDeclAs<ImplicitConceptSpecializationDecl>();
803  E->ArgsAsWritten = Record.readASTTemplateArgumentListInfo();
804  E->Satisfaction = E->isValueDependent() ? nullptr :
805  ASTConstraintSatisfaction::Create(Record.getContext(),
807 }
808 
811  std::string SubstitutedEntity = Record.readString();
812  SourceLocation DiagLoc = Record.readSourceLocation();
813  std::string DiagMessage = Record.readString();
814  return new (Record.getContext())
815  concepts::Requirement::SubstitutionDiagnostic{SubstitutedEntity, DiagLoc,
816  DiagMessage};
817 }
818 
819 void ASTStmtReader::VisitRequiresExpr(RequiresExpr *E) {
820  VisitExpr(E);
821  unsigned NumLocalParameters = Record.readInt();
822  unsigned NumRequirements = Record.readInt();
823  E->RequiresExprBits.RequiresKWLoc = Record.readSourceLocation();
824  E->RequiresExprBits.IsSatisfied = Record.readInt();
825  E->Body = Record.readDeclAs<RequiresExprBodyDecl>();
826  llvm::SmallVector<ParmVarDecl *, 4> LocalParameters;
827  for (unsigned i = 0; i < NumLocalParameters; ++i)
828  LocalParameters.push_back(cast<ParmVarDecl>(Record.readDecl()));
829  std::copy(LocalParameters.begin(), LocalParameters.end(),
830  E->getTrailingObjects<ParmVarDecl *>());
832  for (unsigned i = 0; i < NumRequirements; ++i) {
833  auto RK =
834  static_cast<concepts::Requirement::RequirementKind>(Record.readInt());
835  concepts::Requirement *R = nullptr;
836  switch (RK) {
838  auto Status =
840  Record.readInt());
842  R = new (Record.getContext())
844  else
845  R = new (Record.getContext())
846  concepts::TypeRequirement(Record.readTypeSourceInfo());
847  } break;
850  auto Status =
852  Record.readInt());
854  Expr *> E;
856  E = readSubstitutionDiagnostic(Record);
857  } else
858  E = Record.readExpr();
859 
861  ConceptSpecializationExpr *SubstitutedConstraintExpr = nullptr;
862  SourceLocation NoexceptLoc;
864  Req.emplace();
865  } else {
866  NoexceptLoc = Record.readSourceLocation();
867  switch (/* returnTypeRequirementKind */Record.readInt()) {
868  case 0:
869  // No return type requirement.
870  Req.emplace();
871  break;
872  case 1: {
873  // type-constraint
874  TemplateParameterList *TPL = Record.readTemplateParameterList();
875  if (Status >=
877  SubstitutedConstraintExpr =
878  cast<ConceptSpecializationExpr>(Record.readExpr());
879  Req.emplace(TPL);
880  } break;
881  case 2:
882  // Substitution failure
883  Req.emplace(readSubstitutionDiagnostic(Record));
884  break;
885  }
886  }
887  if (Expr *Ex = E.dyn_cast<Expr *>())
888  R = new (Record.getContext()) concepts::ExprRequirement(
889  Ex, RK == concepts::Requirement::RK_Simple, NoexceptLoc,
890  std::move(*Req), Status, SubstitutedConstraintExpr);
891  else
892  R = new (Record.getContext()) concepts::ExprRequirement(
894  RK == concepts::Requirement::RK_Simple, NoexceptLoc,
895  std::move(*Req));
896  } break;
898  if (/* IsSubstitutionDiagnostic */Record.readInt()) {
899  R = new (Record.getContext()) concepts::NestedRequirement(
901  break;
902  }
903  Expr *E = Record.readExpr();
904  if (E->isInstantiationDependent())
905  R = new (Record.getContext()) concepts::NestedRequirement(E);
906  else
907  R = new (Record.getContext())
908  concepts::NestedRequirement(Record.getContext(), E,
910  } break;
911  }
912  if (!R)
913  continue;
914  Requirements.push_back(R);
915  }
916  std::copy(Requirements.begin(), Requirements.end(),
917  E->getTrailingObjects<concepts::Requirement *>());
918  E->RBraceLoc = Record.readSourceLocation();
919 }
920 
921 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
922  VisitExpr(E);
923  E->setLHS(Record.readSubExpr());
924  E->setRHS(Record.readSubExpr());
925  E->setRBracketLoc(readSourceLocation());
926 }
927 
928 void ASTStmtReader::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E) {
929  VisitExpr(E);
930  E->setBase(Record.readSubExpr());
931  E->setRowIdx(Record.readSubExpr());
932  E->setColumnIdx(Record.readSubExpr());
933  E->setRBracketLoc(readSourceLocation());
934 }
935 
936 void ASTStmtReader::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {
937  VisitExpr(E);
938  E->setBase(Record.readSubExpr());
939  E->setLowerBound(Record.readSubExpr());
940  E->setLength(Record.readSubExpr());
941  E->setStride(Record.readSubExpr());
942  E->setColonLocFirst(readSourceLocation());
943  E->setColonLocSecond(readSourceLocation());
944  E->setRBracketLoc(readSourceLocation());
945 }
946 
947 void ASTStmtReader::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
948  VisitExpr(E);
949  unsigned NumDims = Record.readInt();
950  E->setBase(Record.readSubExpr());
951  SmallVector<Expr *, 4> Dims(NumDims);
952  for (unsigned I = 0; I < NumDims; ++I)
953  Dims[I] = Record.readSubExpr();
954  E->setDimensions(Dims);
955  SmallVector<SourceRange, 4> SRs(NumDims);
956  for (unsigned I = 0; I < NumDims; ++I)
957  SRs[I] = readSourceRange();
958  E->setBracketsRanges(SRs);
959  E->setLParenLoc(readSourceLocation());
960  E->setRParenLoc(readSourceLocation());
961 }
962 
963 void ASTStmtReader::VisitOMPIteratorExpr(OMPIteratorExpr *E) {
964  VisitExpr(E);
965  unsigned NumIters = Record.readInt();
966  E->setIteratorKwLoc(readSourceLocation());
967  E->setLParenLoc(readSourceLocation());
968  E->setRParenLoc(readSourceLocation());
969  for (unsigned I = 0; I < NumIters; ++I) {
970  E->setIteratorDeclaration(I, Record.readDeclRef());
971  E->setAssignmentLoc(I, readSourceLocation());
972  Expr *Begin = Record.readSubExpr();
973  Expr *End = Record.readSubExpr();
974  Expr *Step = Record.readSubExpr();
975  SourceLocation ColonLoc = readSourceLocation();
976  SourceLocation SecColonLoc;
977  if (Step)
978  SecColonLoc = readSourceLocation();
979  E->setIteratorRange(I, Begin, ColonLoc, End, SecColonLoc, Step);
980  // Deserialize helpers
982  HD.CounterVD = cast_or_null<VarDecl>(Record.readDeclRef());
983  HD.Upper = Record.readSubExpr();
984  HD.Update = Record.readSubExpr();
985  HD.CounterUpdate = Record.readSubExpr();
986  E->setHelper(I, HD);
987  }
988 }
989 
990 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
991  VisitExpr(E);
992  unsigned NumArgs = Record.readInt();
993  bool HasFPFeatures = Record.readInt();
994  assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
995  E->setRParenLoc(readSourceLocation());
996  E->setCallee(Record.readSubExpr());
997  for (unsigned I = 0; I != NumArgs; ++I)
998  E->setArg(I, Record.readSubExpr());
999  E->setADLCallKind(static_cast<CallExpr::ADLCallKind>(Record.readInt()));
1000  if (HasFPFeatures)
1002  FPOptionsOverride::getFromOpaqueInt(Record.readInt()));
1003 }
1004 
1005 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1006  VisitCallExpr(E);
1007 }
1008 
1009 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
1010  VisitExpr(E);
1011 
1012  bool HasQualifier = Record.readInt();
1013  bool HasFoundDecl = Record.readInt();
1014  bool HasTemplateInfo = Record.readInt();
1015  unsigned NumTemplateArgs = Record.readInt();
1016 
1017  E->Base = Record.readSubExpr();
1018  E->MemberDecl = Record.readDeclAs<ValueDecl>();
1019  E->MemberDNLoc = Record.readDeclarationNameLoc(E->MemberDecl->getDeclName());
1020  E->MemberLoc = Record.readSourceLocation();
1021  E->MemberExprBits.IsArrow = Record.readInt();
1022  E->MemberExprBits.HasQualifierOrFoundDecl = HasQualifier || HasFoundDecl;
1023  E->MemberExprBits.HasTemplateKWAndArgsInfo = HasTemplateInfo;
1024  E->MemberExprBits.HadMultipleCandidates = Record.readInt();
1025  E->MemberExprBits.NonOdrUseReason = Record.readInt();
1026  E->MemberExprBits.OperatorLoc = Record.readSourceLocation();
1027 
1028  if (HasQualifier || HasFoundDecl) {
1029  DeclAccessPair FoundDecl;
1030  if (HasFoundDecl) {
1031  auto *FoundD = Record.readDeclAs<NamedDecl>();
1032  auto AS = (AccessSpecifier)Record.readInt();
1033  FoundDecl = DeclAccessPair::make(FoundD, AS);
1034  } else {
1035  FoundDecl = DeclAccessPair::make(E->MemberDecl,
1036  E->MemberDecl->getAccess());
1037  }
1038  E->getTrailingObjects<MemberExprNameQualifier>()->FoundDecl = FoundDecl;
1039 
1040  NestedNameSpecifierLoc QualifierLoc;
1041  if (HasQualifier)
1042  QualifierLoc = Record.readNestedNameSpecifierLoc();
1043  E->getTrailingObjects<MemberExprNameQualifier>()->QualifierLoc =
1044  QualifierLoc;
1045  }
1046 
1047  if (HasTemplateInfo)
1048  ReadTemplateKWAndArgsInfo(
1049  *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1050  E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
1051 }
1052 
1053 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
1054  VisitExpr(E);
1055  E->setBase(Record.readSubExpr());
1056  E->setIsaMemberLoc(readSourceLocation());
1057  E->setOpLoc(readSourceLocation());
1058  E->setArrow(Record.readInt());
1059 }
1060 
1061 void ASTStmtReader::
1062 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
1063  VisitExpr(E);
1064  E->Operand = Record.readSubExpr();
1065  E->setShouldCopy(Record.readInt());
1066 }
1067 
1068 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
1069  VisitExplicitCastExpr(E);
1070  E->LParenLoc = readSourceLocation();
1071  E->BridgeKeywordLoc = readSourceLocation();
1072  E->Kind = Record.readInt();
1073 }
1074 
1075 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
1076  VisitExpr(E);
1077  unsigned NumBaseSpecs = Record.readInt();
1078  assert(NumBaseSpecs == E->path_size());
1079  unsigned HasFPFeatures = Record.readInt();
1080  assert(E->hasStoredFPFeatures() == HasFPFeatures);
1081  E->setSubExpr(Record.readSubExpr());
1082  E->setCastKind((CastKind)Record.readInt());
1083  CastExpr::path_iterator BaseI = E->path_begin();
1084  while (NumBaseSpecs--) {
1085  auto *BaseSpec = new (Record.getContext()) CXXBaseSpecifier;
1086  *BaseSpec = Record.readCXXBaseSpecifier();
1087  *BaseI++ = BaseSpec;
1088  }
1089  if (HasFPFeatures)
1090  *E->getTrailingFPFeatures() =
1091  FPOptionsOverride::getFromOpaqueInt(Record.readInt());
1092 }
1093 
1094 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
1095  bool hasFP_Features;
1096  VisitExpr(E);
1097  E->setHasStoredFPFeatures(hasFP_Features = Record.readInt());
1098  E->setOpcode((BinaryOperator::Opcode)Record.readInt());
1099  E->setLHS(Record.readSubExpr());
1100  E->setRHS(Record.readSubExpr());
1101  E->setOperatorLoc(readSourceLocation());
1102  if (hasFP_Features)
1104  FPOptionsOverride::getFromOpaqueInt(Record.readInt()));
1105 }
1106 
1107 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
1108  VisitBinaryOperator(E);
1109  E->setComputationLHSType(Record.readType());
1110  E->setComputationResultType(Record.readType());
1111 }
1112 
1113 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
1114  VisitExpr(E);
1115  E->SubExprs[ConditionalOperator::COND] = Record.readSubExpr();
1116  E->SubExprs[ConditionalOperator::LHS] = Record.readSubExpr();
1117  E->SubExprs[ConditionalOperator::RHS] = Record.readSubExpr();
1118  E->QuestionLoc = readSourceLocation();
1119  E->ColonLoc = readSourceLocation();
1120 }
1121 
1122 void
1123 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
1124  VisitExpr(E);
1125  E->OpaqueValue = cast<OpaqueValueExpr>(Record.readSubExpr());
1126  E->SubExprs[BinaryConditionalOperator::COMMON] = Record.readSubExpr();
1127  E->SubExprs[BinaryConditionalOperator::COND] = Record.readSubExpr();
1128  E->SubExprs[BinaryConditionalOperator::LHS] = Record.readSubExpr();
1129  E->SubExprs[BinaryConditionalOperator::RHS] = Record.readSubExpr();
1130  E->QuestionLoc = readSourceLocation();
1131  E->ColonLoc = readSourceLocation();
1132 }
1133 
1134 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
1135  VisitCastExpr(E);
1136  E->setIsPartOfExplicitCast(Record.readInt());
1137 }
1138 
1139 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
1140  VisitCastExpr(E);
1141  E->setTypeInfoAsWritten(readTypeSourceInfo());
1142 }
1143 
1144 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
1145  VisitExplicitCastExpr(E);
1146  E->setLParenLoc(readSourceLocation());
1147  E->setRParenLoc(readSourceLocation());
1148 }
1149 
1150 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
1151  VisitExpr(E);
1152  E->setLParenLoc(readSourceLocation());
1153  E->setTypeSourceInfo(readTypeSourceInfo());
1154  E->setInitializer(Record.readSubExpr());
1155  E->setFileScope(Record.readInt());
1156 }
1157 
1158 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
1159  VisitExpr(E);
1160  E->setBase(Record.readSubExpr());
1161  E->setAccessor(Record.readIdentifier());
1162  E->setAccessorLoc(readSourceLocation());
1163 }
1164 
1165 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
1166  VisitExpr(E);
1167  if (auto *SyntForm = cast_or_null<InitListExpr>(Record.readSubStmt()))
1168  E->setSyntacticForm(SyntForm);
1169  E->setLBraceLoc(readSourceLocation());
1170  E->setRBraceLoc(readSourceLocation());
1171  bool isArrayFiller = Record.readInt();
1172  Expr *filler = nullptr;
1173  if (isArrayFiller) {
1174  filler = Record.readSubExpr();
1175  E->ArrayFillerOrUnionFieldInit = filler;
1176  } else
1177  E->ArrayFillerOrUnionFieldInit = readDeclAs<FieldDecl>();
1178  E->sawArrayRangeDesignator(Record.readInt());
1179  unsigned NumInits = Record.readInt();
1180  E->reserveInits(Record.getContext(), NumInits);
1181  if (isArrayFiller) {
1182  for (unsigned I = 0; I != NumInits; ++I) {
1183  Expr *init = Record.readSubExpr();
1184  E->updateInit(Record.getContext(), I, init ? init : filler);
1185  }
1186  } else {
1187  for (unsigned I = 0; I != NumInits; ++I)
1188  E->updateInit(Record.getContext(), I, Record.readSubExpr());
1189  }
1190 }
1191 
1192 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
1194 
1195  VisitExpr(E);
1196  unsigned NumSubExprs = Record.readInt();
1197  assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
1198  for (unsigned I = 0; I != NumSubExprs; ++I)
1199  E->setSubExpr(I, Record.readSubExpr());
1200  E->setEqualOrColonLoc(readSourceLocation());
1201  E->setGNUSyntax(Record.readInt());
1202 
1203  SmallVector<Designator, 4> Designators;
1204  while (Record.getIdx() < Record.size()) {
1205  switch ((DesignatorTypes)Record.readInt()) {
1206  case DESIG_FIELD_DECL: {
1207  auto *Field = readDeclAs<FieldDecl>();
1208  SourceLocation DotLoc = readSourceLocation();
1209  SourceLocation FieldLoc = readSourceLocation();
1210  Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
1211  FieldLoc));
1212  Designators.back().setField(Field);
1213  break;
1214  }
1215 
1216  case DESIG_FIELD_NAME: {
1217  const IdentifierInfo *Name = Record.readIdentifier();
1218  SourceLocation DotLoc = readSourceLocation();
1219  SourceLocation FieldLoc = readSourceLocation();
1220  Designators.push_back(Designator(Name, DotLoc, FieldLoc));
1221  break;
1222  }
1223 
1224  case DESIG_ARRAY: {
1225  unsigned Index = Record.readInt();
1226  SourceLocation LBracketLoc = readSourceLocation();
1227  SourceLocation RBracketLoc = readSourceLocation();
1228  Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
1229  break;
1230  }
1231 
1232  case DESIG_ARRAY_RANGE: {
1233  unsigned Index = Record.readInt();
1234  SourceLocation LBracketLoc = readSourceLocation();
1235  SourceLocation EllipsisLoc = readSourceLocation();
1236  SourceLocation RBracketLoc = readSourceLocation();
1237  Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
1238  RBracketLoc));
1239  break;
1240  }
1241  }
1242  }
1243  E->setDesignators(Record.getContext(),
1244  Designators.data(), Designators.size());
1245 }
1246 
1247 void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
1248  VisitExpr(E);
1249  E->setBase(Record.readSubExpr());
1250  E->setUpdater(Record.readSubExpr());
1251 }
1252 
1253 void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) {
1254  VisitExpr(E);
1255 }
1256 
1257 void ASTStmtReader::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
1258  VisitExpr(E);
1259  E->SubExprs[0] = Record.readSubExpr();
1260  E->SubExprs[1] = Record.readSubExpr();
1261 }
1262 
1263 void ASTStmtReader::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
1264  VisitExpr(E);
1265 }
1266 
1267 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
1268  VisitExpr(E);
1269 }
1270 
1271 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
1272  VisitExpr(E);
1273  E->setSubExpr(Record.readSubExpr());
1274  E->setWrittenTypeInfo(readTypeSourceInfo());
1275  E->setBuiltinLoc(readSourceLocation());
1276  E->setRParenLoc(readSourceLocation());
1277  E->setIsMicrosoftABI(Record.readInt());
1278 }
1279 
1280 void ASTStmtReader::VisitSourceLocExpr(SourceLocExpr *E) {
1281  VisitExpr(E);
1282  E->ParentContext = readDeclAs<DeclContext>();
1283  E->BuiltinLoc = readSourceLocation();
1284  E->RParenLoc = readSourceLocation();
1285  E->SourceLocExprBits.Kind =
1286  static_cast<SourceLocExpr::IdentKind>(Record.readInt());
1287 }
1288 
1289 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
1290  VisitExpr(E);
1291  E->setAmpAmpLoc(readSourceLocation());
1292  E->setLabelLoc(readSourceLocation());
1293  E->setLabel(readDeclAs<LabelDecl>());
1294 }
1295 
1296 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
1297  VisitExpr(E);
1298  E->setLParenLoc(readSourceLocation());
1299  E->setRParenLoc(readSourceLocation());
1300  E->setSubStmt(cast_or_null<CompoundStmt>(Record.readSubStmt()));
1301  E->StmtExprBits.TemplateDepth = Record.readInt();
1302 }
1303 
1304 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
1305  VisitExpr(E);
1306  E->setCond(Record.readSubExpr());
1307  E->setLHS(Record.readSubExpr());
1308  E->setRHS(Record.readSubExpr());
1309  E->setBuiltinLoc(readSourceLocation());
1310  E->setRParenLoc(readSourceLocation());
1311  E->setIsConditionTrue(Record.readInt());
1312 }
1313 
1314 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
1315  VisitExpr(E);
1316  E->setTokenLocation(readSourceLocation());
1317 }
1318 
1319 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
1320  VisitExpr(E);
1322  unsigned NumExprs = Record.readInt();
1323  while (NumExprs--)
1324  Exprs.push_back(Record.readSubExpr());
1325  E->setExprs(Record.getContext(), Exprs);
1326  E->setBuiltinLoc(readSourceLocation());
1327  E->setRParenLoc(readSourceLocation());
1328 }
1329 
1330 void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) {
1331  VisitExpr(E);
1332  E->BuiltinLoc = readSourceLocation();
1333  E->RParenLoc = readSourceLocation();
1334  E->TInfo = readTypeSourceInfo();
1335  E->SrcExpr = Record.readSubExpr();
1336 }
1337 
1338 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
1339  VisitExpr(E);
1340  E->setBlockDecl(readDeclAs<BlockDecl>());
1341 }
1342 
1343 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
1344  VisitExpr(E);
1345 
1346  unsigned NumAssocs = Record.readInt();
1347  assert(NumAssocs == E->getNumAssocs() && "Wrong NumAssocs!");
1348  E->ResultIndex = Record.readInt();
1349  E->GenericSelectionExprBits.GenericLoc = readSourceLocation();
1350  E->DefaultLoc = readSourceLocation();
1351  E->RParenLoc = readSourceLocation();
1352 
1353  Stmt **Stmts = E->getTrailingObjects<Stmt *>();
1354  // Add 1 to account for the controlling expression which is the first
1355  // expression in the trailing array of Stmt *. This is not needed for
1356  // the trailing array of TypeSourceInfo *.
1357  for (unsigned I = 0, N = NumAssocs + 1; I < N; ++I)
1358  Stmts[I] = Record.readSubExpr();
1359 
1360  TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>();
1361  for (unsigned I = 0, N = NumAssocs; I < N; ++I)
1362  TSIs[I] = readTypeSourceInfo();
1363 }
1364 
1365 void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
1366  VisitExpr(E);
1367  unsigned numSemanticExprs = Record.readInt();
1368  assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs);
1369  E->PseudoObjectExprBits.ResultIndex = Record.readInt();
1370 
1371  // Read the syntactic expression.
1372  E->getSubExprsBuffer()[0] = Record.readSubExpr();
1373 
1374  // Read all the semantic expressions.
1375  for (unsigned i = 0; i != numSemanticExprs; ++i) {
1376  Expr *subExpr = Record.readSubExpr();
1377  E->getSubExprsBuffer()[i+1] = subExpr;
1378  }
1379 }
1380 
1381 void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {
1382  VisitExpr(E);
1383  E->Op = AtomicExpr::AtomicOp(Record.readInt());
1384  E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op);
1385  for (unsigned I = 0; I != E->NumSubExprs; ++I)
1386  E->SubExprs[I] = Record.readSubExpr();
1387  E->BuiltinLoc = readSourceLocation();
1388  E->RParenLoc = readSourceLocation();
1389 }
1390 
1391 //===----------------------------------------------------------------------===//
1392 // Objective-C Expressions and Statements
1393 
1394 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
1395  VisitExpr(E);
1396  E->setString(cast<StringLiteral>(Record.readSubStmt()));
1397  E->setAtLoc(readSourceLocation());
1398 }
1399 
1400 void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
1401  VisitExpr(E);
1402  // could be one of several IntegerLiteral, FloatLiteral, etc.
1403  E->SubExpr = Record.readSubStmt();
1404  E->BoxingMethod = readDeclAs<ObjCMethodDecl>();
1405  E->Range = readSourceRange();
1406 }
1407 
1408 void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
1409  VisitExpr(E);
1410  unsigned NumElements = Record.readInt();
1411  assert(NumElements == E->getNumElements() && "Wrong number of elements");
1412  Expr **Elements = E->getElements();
1413  for (unsigned I = 0, N = NumElements; I != N; ++I)
1414  Elements[I] = Record.readSubExpr();
1415  E->ArrayWithObjectsMethod = readDeclAs<ObjCMethodDecl>();
1416  E->Range = readSourceRange();
1417 }
1418 
1419 void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
1420  VisitExpr(E);
1421  unsigned NumElements = Record.readInt();
1422  assert(NumElements == E->getNumElements() && "Wrong number of elements");
1423  bool HasPackExpansions = Record.readInt();
1424  assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch");
1425  auto *KeyValues =
1426  E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>();
1427  auto *Expansions =
1428  E->getTrailingObjects<ObjCDictionaryLiteral::ExpansionData>();
1429  for (unsigned I = 0; I != NumElements; ++I) {
1430  KeyValues[I].Key = Record.readSubExpr();
1431  KeyValues[I].Value = Record.readSubExpr();
1432  if (HasPackExpansions) {
1433  Expansions[I].EllipsisLoc = readSourceLocation();
1434  Expansions[I].NumExpansionsPlusOne = Record.readInt();
1435  }
1436  }
1437  E->DictWithObjectsMethod = readDeclAs<ObjCMethodDecl>();
1438  E->Range = readSourceRange();
1439 }
1440 
1441 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
1442  VisitExpr(E);
1443  E->setEncodedTypeSourceInfo(readTypeSourceInfo());
1444  E->setAtLoc(readSourceLocation());
1445  E->setRParenLoc(readSourceLocation());
1446 }
1447 
1448 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
1449  VisitExpr(E);
1450  E->setSelector(Record.readSelector());
1451  E->setAtLoc(readSourceLocation());
1452  E->setRParenLoc(readSourceLocation());
1453 }
1454 
1455 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
1456  VisitExpr(E);
1457  E->setProtocol(readDeclAs<ObjCProtocolDecl>());
1458  E->setAtLoc(readSourceLocation());
1459  E->ProtoLoc = readSourceLocation();
1460  E->setRParenLoc(readSourceLocation());
1461 }
1462 
1463 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
1464  VisitExpr(E);
1465  E->setDecl(readDeclAs<ObjCIvarDecl>());
1466  E->setLocation(readSourceLocation());
1467  E->setOpLoc(readSourceLocation());
1468  E->setBase(Record.readSubExpr());
1469  E->setIsArrow(Record.readInt());
1470  E->setIsFreeIvar(Record.readInt());
1471 }
1472 
1473 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
1474  VisitExpr(E);
1475  unsigned MethodRefFlags = Record.readInt();
1476  bool Implicit = Record.readInt() != 0;
1477  if (Implicit) {
1478  auto *Getter = readDeclAs<ObjCMethodDecl>();
1479  auto *Setter = readDeclAs<ObjCMethodDecl>();
1480  E->setImplicitProperty(Getter, Setter, MethodRefFlags);
1481  } else {
1482  E->setExplicitProperty(readDeclAs<ObjCPropertyDecl>(), MethodRefFlags);
1483  }
1484  E->setLocation(readSourceLocation());
1485  E->setReceiverLocation(readSourceLocation());
1486  switch (Record.readInt()) {
1487  case 0:
1488  E->setBase(Record.readSubExpr());
1489  break;
1490  case 1:
1491  E->setSuperReceiver(Record.readType());
1492  break;
1493  case 2:
1494  E->setClassReceiver(readDeclAs<ObjCInterfaceDecl>());
1495  break;
1496  }
1497 }
1498 
1499 void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1500  VisitExpr(E);
1501  E->setRBracket(readSourceLocation());
1502  E->setBaseExpr(Record.readSubExpr());
1503  E->setKeyExpr(Record.readSubExpr());
1504  E->GetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>();
1505  E->SetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>();
1506 }
1507 
1508 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1509  VisitExpr(E);
1510  assert(Record.peekInt() == E->getNumArgs());
1511  Record.skipInts(1);
1512  unsigned NumStoredSelLocs = Record.readInt();
1513  E->SelLocsKind = Record.readInt();
1514  E->setDelegateInitCall(Record.readInt());
1515  E->IsImplicit = Record.readInt();
1516  auto Kind = static_cast<ObjCMessageExpr::ReceiverKind>(Record.readInt());
1517  switch (Kind) {
1519  E->setInstanceReceiver(Record.readSubExpr());
1520  break;
1521 
1523  E->setClassReceiver(readTypeSourceInfo());
1524  break;
1525 
1528  QualType T = Record.readType();
1529  SourceLocation SuperLoc = readSourceLocation();
1530  E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
1531  break;
1532  }
1533  }
1534 
1535  assert(Kind == E->getReceiverKind());
1536 
1537  if (Record.readInt())
1538  E->setMethodDecl(readDeclAs<ObjCMethodDecl>());
1539  else
1540  E->setSelector(Record.readSelector());
1541 
1542  E->LBracLoc = readSourceLocation();
1543  E->RBracLoc = readSourceLocation();
1544 
1545  for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1546  E->setArg(I, Record.readSubExpr());
1547 
1548  SourceLocation *Locs = E->getStoredSelLocs();
1549  for (unsigned I = 0; I != NumStoredSelLocs; ++I)
1550  Locs[I] = readSourceLocation();
1551 }
1552 
1553 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
1554  VisitStmt(S);
1555  S->setElement(Record.readSubStmt());
1556  S->setCollection(Record.readSubExpr());
1557  S->setBody(Record.readSubStmt());
1558  S->setForLoc(readSourceLocation());
1559  S->setRParenLoc(readSourceLocation());
1560 }
1561 
1562 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
1563  VisitStmt(S);
1564  S->setCatchBody(Record.readSubStmt());
1565  S->setCatchParamDecl(readDeclAs<VarDecl>());
1566  S->setAtCatchLoc(readSourceLocation());
1567  S->setRParenLoc(readSourceLocation());
1568 }
1569 
1570 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
1571  VisitStmt(S);
1572  S->setFinallyBody(Record.readSubStmt());
1573  S->setAtFinallyLoc(readSourceLocation());
1574 }
1575 
1576 void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1577  VisitStmt(S); // FIXME: no test coverage.
1578  S->setSubStmt(Record.readSubStmt());
1579  S->setAtLoc(readSourceLocation());
1580 }
1581 
1582 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
1583  VisitStmt(S);
1584  assert(Record.peekInt() == S->getNumCatchStmts());
1585  Record.skipInts(1);
1586  bool HasFinally = Record.readInt();
1587  S->setTryBody(Record.readSubStmt());
1588  for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
1589  S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Record.readSubStmt()));
1590 
1591  if (HasFinally)
1592  S->setFinallyStmt(Record.readSubStmt());
1593  S->setAtTryLoc(readSourceLocation());
1594 }
1595 
1596 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1597  VisitStmt(S); // FIXME: no test coverage.
1598  S->setSynchExpr(Record.readSubStmt());
1599  S->setSynchBody(Record.readSubStmt());
1600  S->setAtSynchronizedLoc(readSourceLocation());
1601 }
1602 
1603 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
1604  VisitStmt(S); // FIXME: no test coverage.
1605  S->setThrowExpr(Record.readSubStmt());
1606  S->setThrowLoc(readSourceLocation());
1607 }
1608 
1609 void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1610  VisitExpr(E);
1611  E->setValue(Record.readInt());
1612  E->setLocation(readSourceLocation());
1613 }
1614 
1615 void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
1616  VisitExpr(E);
1617  SourceRange R = Record.readSourceRange();
1618  E->AtLoc = R.getBegin();
1619  E->RParen = R.getEnd();
1620  E->VersionToCheck = Record.readVersionTuple();
1621 }
1622 
1623 //===----------------------------------------------------------------------===//
1624 // C++ Expressions and Statements
1625 //===----------------------------------------------------------------------===//
1626 
1627 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
1628  VisitStmt(S);
1629  S->CatchLoc = readSourceLocation();
1630  S->ExceptionDecl = readDeclAs<VarDecl>();
1631  S->HandlerBlock = Record.readSubStmt();
1632 }
1633 
1634 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
1635  VisitStmt(S);
1636  assert(Record.peekInt() == S->getNumHandlers() && "NumStmtFields is wrong ?");
1637  Record.skipInts(1);
1638  S->TryLoc = readSourceLocation();
1639  S->getStmts()[0] = Record.readSubStmt();
1640  for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1641  S->getStmts()[i + 1] = Record.readSubStmt();
1642 }
1643 
1644 void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1645  VisitStmt(S);
1646  S->ForLoc = readSourceLocation();
1647  S->CoawaitLoc = readSourceLocation();
1648  S->ColonLoc = readSourceLocation();
1649  S->RParenLoc = readSourceLocation();
1650  S->setInit(Record.readSubStmt());
1651  S->setRangeStmt(Record.readSubStmt());
1652  S->setBeginStmt(Record.readSubStmt());
1653  S->setEndStmt(Record.readSubStmt());
1654  S->setCond(Record.readSubExpr());
1655  S->setInc(Record.readSubExpr());
1656  S->setLoopVarStmt(Record.readSubStmt());
1657  S->setBody(Record.readSubStmt());
1658 }
1659 
1660 void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1661  VisitStmt(S);
1662  S->KeywordLoc = readSourceLocation();
1663  S->IsIfExists = Record.readInt();
1664  S->QualifierLoc = Record.readNestedNameSpecifierLoc();
1665  S->NameInfo = Record.readDeclarationNameInfo();
1666  S->SubStmt = Record.readSubStmt();
1667 }
1668 
1669 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1670  VisitCallExpr(E);
1671  E->CXXOperatorCallExprBits.OperatorKind = Record.readInt();
1672  E->Range = Record.readSourceRange();
1673 }
1674 
1675 void ASTStmtReader::VisitCXXRewrittenBinaryOperator(
1677  VisitExpr(E);
1678  E->CXXRewrittenBinaryOperatorBits.IsReversed = Record.readInt();
1679  E->SemanticForm = Record.readSubExpr();
1680 }
1681 
1682 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
1683  VisitExpr(E);
1684 
1685  unsigned NumArgs = Record.readInt();
1686  assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
1687 
1688  E->CXXConstructExprBits.Elidable = Record.readInt();
1689  E->CXXConstructExprBits.HadMultipleCandidates = Record.readInt();
1690  E->CXXConstructExprBits.ListInitialization = Record.readInt();
1691  E->CXXConstructExprBits.StdInitListInitialization = Record.readInt();
1692  E->CXXConstructExprBits.ZeroInitialization = Record.readInt();
1693  E->CXXConstructExprBits.ConstructionKind = Record.readInt();
1694  E->CXXConstructExprBits.Loc = readSourceLocation();
1695  E->Constructor = readDeclAs<CXXConstructorDecl>();
1696  E->ParenOrBraceRange = readSourceRange();
1697 
1698  for (unsigned I = 0; I != NumArgs; ++I)
1699  E->setArg(I, Record.readSubExpr());
1700 }
1701 
1702 void ASTStmtReader::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
1703  VisitExpr(E);
1704  E->Constructor = readDeclAs<CXXConstructorDecl>();
1705  E->Loc = readSourceLocation();
1706  E->ConstructsVirtualBase = Record.readInt();
1707  E->InheritedFromVirtualBase = Record.readInt();
1708 }
1709 
1710 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1711  VisitCXXConstructExpr(E);
1712  E->TSI = readTypeSourceInfo();
1713 }
1714 
1715 void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {
1716  VisitExpr(E);
1717  unsigned NumCaptures = Record.readInt();
1718  (void)NumCaptures;
1719  assert(NumCaptures == E->LambdaExprBits.NumCaptures);
1720  E->IntroducerRange = readSourceRange();
1721  E->LambdaExprBits.CaptureDefault = Record.readInt();
1722  E->CaptureDefaultLoc = readSourceLocation();
1723  E->LambdaExprBits.ExplicitParams = Record.readInt();
1724  E->LambdaExprBits.ExplicitResultType = Record.readInt();
1725  E->ClosingBrace = readSourceLocation();
1726 
1727  // Read capture initializers.
1729  CEnd = E->capture_init_end();
1730  C != CEnd; ++C)
1731  *C = Record.readSubExpr();
1732 
1733  // The body will be lazily deserialized when needed from the call operator
1734  // declaration.
1735 }
1736 
1737 void
1738 ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1739  VisitExpr(E);
1740  E->SubExpr = Record.readSubExpr();
1741 }
1742 
1743 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1744  VisitExplicitCastExpr(E);
1745  SourceRange R = readSourceRange();
1746  E->Loc = R.getBegin();
1747  E->RParenLoc = R.getEnd();
1748  R = readSourceRange();
1749  E->AngleBrackets = R;
1750 }
1751 
1752 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1753  return VisitCXXNamedCastExpr(E);
1754 }
1755 
1756 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1757  return VisitCXXNamedCastExpr(E);
1758 }
1759 
1760 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1761  return VisitCXXNamedCastExpr(E);
1762 }
1763 
1764 void ASTStmtReader::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) {
1765  return VisitCXXNamedCastExpr(E);
1766 }
1767 
1768 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1769  return VisitCXXNamedCastExpr(E);
1770 }
1771 
1772 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1773  VisitExplicitCastExpr(E);
1774  E->setLParenLoc(readSourceLocation());
1775  E->setRParenLoc(readSourceLocation());
1776 }
1777 
1778 void ASTStmtReader::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) {
1779  VisitExplicitCastExpr(E);
1780  E->KWLoc = readSourceLocation();
1781  E->RParenLoc = readSourceLocation();
1782 }
1783 
1784 void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1785  VisitCallExpr(E);
1786  E->UDSuffixLoc = readSourceLocation();
1787 }
1788 
1789 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1790  VisitExpr(E);
1791  E->setValue(Record.readInt());
1792  E->setLocation(readSourceLocation());
1793 }
1794 
1795 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1796  VisitExpr(E);
1797  E->setLocation(readSourceLocation());
1798 }
1799 
1800 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1801  VisitExpr(E);
1802  E->setSourceRange(readSourceRange());
1803  if (E->isTypeOperand())
1804  E->Operand = readTypeSourceInfo();
1805  else
1806  E->Operand = Record.readSubExpr();
1807 }
1808 
1809 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1810  VisitExpr(E);
1811  E->setLocation(readSourceLocation());
1812  E->setImplicit(Record.readInt());
1813 }
1814 
1815 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1816  VisitExpr(E);
1817  E->CXXThrowExprBits.ThrowLoc = readSourceLocation();
1818  E->Operand = Record.readSubExpr();
1819  E->CXXThrowExprBits.IsThrownVariableInScope = Record.readInt();
1820 }
1821 
1822 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1823  VisitExpr(E);
1824  E->Param = readDeclAs<ParmVarDecl>();
1825  E->UsedContext = readDeclAs<DeclContext>();
1826  E->CXXDefaultArgExprBits.Loc = readSourceLocation();
1827 }
1828 
1829 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1830  VisitExpr(E);
1831  E->Field = readDeclAs<FieldDecl>();
1832  E->UsedContext = readDeclAs<DeclContext>();
1833  E->CXXDefaultInitExprBits.Loc = readSourceLocation();
1834 }
1835 
1836 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1837  VisitExpr(E);
1838  E->setTemporary(Record.readCXXTemporary());
1839  E->setSubExpr(Record.readSubExpr());
1840 }
1841 
1842 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1843  VisitExpr(E);
1844  E->TypeInfo = readTypeSourceInfo();
1845  E->CXXScalarValueInitExprBits.RParenLoc = readSourceLocation();
1846 }
1847 
1848 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1849  VisitExpr(E);
1850 
1851  bool IsArray = Record.readInt();
1852  bool HasInit = Record.readInt();
1853  unsigned NumPlacementArgs = Record.readInt();
1854  bool IsParenTypeId = Record.readInt();
1855 
1856  E->CXXNewExprBits.IsGlobalNew = Record.readInt();
1857  E->CXXNewExprBits.ShouldPassAlignment = Record.readInt();
1858  E->CXXNewExprBits.UsualArrayDeleteWantsSize = Record.readInt();
1859  E->CXXNewExprBits.StoredInitializationStyle = Record.readInt();
1860 
1861  assert((IsArray == E->isArray()) && "Wrong IsArray!");
1862  assert((HasInit == E->hasInitializer()) && "Wrong HasInit!");
1863  assert((NumPlacementArgs == E->getNumPlacementArgs()) &&
1864  "Wrong NumPlacementArgs!");
1865  assert((IsParenTypeId == E->isParenTypeId()) && "Wrong IsParenTypeId!");
1866  (void)IsArray;
1867  (void)HasInit;
1868  (void)NumPlacementArgs;
1869 
1870  E->setOperatorNew(readDeclAs<FunctionDecl>());
1871  E->setOperatorDelete(readDeclAs<FunctionDecl>());
1872  E->AllocatedTypeInfo = readTypeSourceInfo();
1873  if (IsParenTypeId)
1874  E->getTrailingObjects<SourceRange>()[0] = readSourceRange();
1875  E->Range = readSourceRange();
1876  E->DirectInitRange = readSourceRange();
1877 
1878  // Install all the subexpressions.
1880  N = E->raw_arg_end();
1881  I != N; ++I)
1882  *I = Record.readSubStmt();
1883 }
1884 
1885 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1886  VisitExpr(E);
1887  E->CXXDeleteExprBits.GlobalDelete = Record.readInt();
1888  E->CXXDeleteExprBits.ArrayForm = Record.readInt();
1889  E->CXXDeleteExprBits.ArrayFormAsWritten = Record.readInt();
1890  E->CXXDeleteExprBits.UsualArrayDeleteWantsSize = Record.readInt();
1891  E->OperatorDelete = readDeclAs<FunctionDecl>();
1892  E->Argument = Record.readSubExpr();
1893  E->CXXDeleteExprBits.Loc = readSourceLocation();
1894 }
1895 
1896 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1897  VisitExpr(E);
1898 
1899  E->Base = Record.readSubExpr();
1900  E->IsArrow = Record.readInt();
1901  E->OperatorLoc = readSourceLocation();
1902  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1903  E->ScopeType = readTypeSourceInfo();
1904  E->ColonColonLoc = readSourceLocation();
1905  E->TildeLoc = readSourceLocation();
1906 
1907  IdentifierInfo *II = Record.readIdentifier();
1908  if (II)
1909  E->setDestroyedType(II, readSourceLocation());
1910  else
1911  E->setDestroyedType(readTypeSourceInfo());
1912 }
1913 
1914 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
1915  VisitExpr(E);
1916 
1917  unsigned NumObjects = Record.readInt();
1918  assert(NumObjects == E->getNumObjects());
1919  for (unsigned i = 0; i != NumObjects; ++i) {
1920  unsigned CleanupKind = Record.readInt();
1922  if (CleanupKind == COK_Block)
1923  Obj = readDeclAs<BlockDecl>();
1924  else if (CleanupKind == COK_CompoundLiteral)
1925  Obj = cast<CompoundLiteralExpr>(Record.readSubExpr());
1926  else
1927  llvm_unreachable("unexpected cleanup object type");
1928  E->getTrailingObjects<ExprWithCleanups::CleanupObject>()[i] = Obj;
1929  }
1930 
1931  E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record.readInt();
1932  E->SubExpr = Record.readSubExpr();
1933 }
1934 
1935 void ASTStmtReader::VisitCXXDependentScopeMemberExpr(
1937  VisitExpr(E);
1938 
1939  bool HasTemplateKWAndArgsInfo = Record.readInt();
1940  unsigned NumTemplateArgs = Record.readInt();
1941  bool HasFirstQualifierFoundInScope = Record.readInt();
1942 
1943  assert((HasTemplateKWAndArgsInfo == E->hasTemplateKWAndArgsInfo()) &&
1944  "Wrong HasTemplateKWAndArgsInfo!");
1945  assert(
1946  (HasFirstQualifierFoundInScope == E->hasFirstQualifierFoundInScope()) &&
1947  "Wrong HasFirstQualifierFoundInScope!");
1948 
1949  if (HasTemplateKWAndArgsInfo)
1950  ReadTemplateKWAndArgsInfo(
1951  *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1952  E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
1953 
1954  assert((NumTemplateArgs == E->getNumTemplateArgs()) &&
1955  "Wrong NumTemplateArgs!");
1956 
1957  E->CXXDependentScopeMemberExprBits.IsArrow = Record.readInt();
1958  E->CXXDependentScopeMemberExprBits.OperatorLoc = readSourceLocation();
1959  E->BaseType = Record.readType();
1960  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1961  E->Base = Record.readSubExpr();
1962 
1963  if (HasFirstQualifierFoundInScope)
1964  *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>();
1965 
1966  E->MemberNameInfo = Record.readDeclarationNameInfo();
1967 }
1968 
1969 void
1970 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1971  VisitExpr(E);
1972 
1973  if (Record.readInt()) // HasTemplateKWAndArgsInfo
1974  ReadTemplateKWAndArgsInfo(
1975  *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1976  E->getTrailingObjects<TemplateArgumentLoc>(),
1977  /*NumTemplateArgs=*/Record.readInt());
1978 
1979  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1980  E->NameInfo = Record.readDeclarationNameInfo();
1981 }
1982 
1983 void
1984 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1985  VisitExpr(E);
1986  assert(Record.peekInt() == E->getNumArgs() &&
1987  "Read wrong record during creation ?");
1988  Record.skipInts(1);
1989  for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1990  E->setArg(I, Record.readSubExpr());
1991  E->TSI = readTypeSourceInfo();
1992  E->setLParenLoc(readSourceLocation());
1993  E->setRParenLoc(readSourceLocation());
1994 }
1995 
1996 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
1997  VisitExpr(E);
1998 
1999  unsigned NumResults = Record.readInt();
2000  bool HasTemplateKWAndArgsInfo = Record.readInt();
2001  assert((E->getNumDecls() == NumResults) && "Wrong NumResults!");
2002  assert((E->hasTemplateKWAndArgsInfo() == HasTemplateKWAndArgsInfo) &&
2003  "Wrong HasTemplateKWAndArgsInfo!");
2004 
2005  if (HasTemplateKWAndArgsInfo) {
2006  unsigned NumTemplateArgs = Record.readInt();
2007  ReadTemplateKWAndArgsInfo(*E->getTrailingASTTemplateKWAndArgsInfo(),
2009  NumTemplateArgs);
2010  assert((E->getNumTemplateArgs() == NumTemplateArgs) &&
2011  "Wrong NumTemplateArgs!");
2012  }
2013 
2014  UnresolvedSet<8> Decls;
2015  for (unsigned I = 0; I != NumResults; ++I) {
2016  auto *D = readDeclAs<NamedDecl>();
2017  auto AS = (AccessSpecifier)Record.readInt();
2018  Decls.addDecl(D, AS);
2019  }
2020 
2021  DeclAccessPair *Results = E->getTrailingResults();
2022  UnresolvedSetIterator Iter = Decls.begin();
2023  for (unsigned I = 0; I != NumResults; ++I) {
2024  Results[I] = (Iter + I).getPair();
2025  }
2026 
2027  E->NameInfo = Record.readDeclarationNameInfo();
2028  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2029 }
2030 
2031 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
2032  VisitOverloadExpr(E);
2033  E->UnresolvedMemberExprBits.IsArrow = Record.readInt();
2034  E->UnresolvedMemberExprBits.HasUnresolvedUsing = Record.readInt();
2035  E->Base = Record.readSubExpr();
2036  E->BaseType = Record.readType();
2037  E->OperatorLoc = readSourceLocation();
2038 }
2039 
2040 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
2041  VisitOverloadExpr(E);
2042  E->UnresolvedLookupExprBits.RequiresADL = Record.readInt();
2043  E->UnresolvedLookupExprBits.Overloaded = Record.readInt();
2044  E->NamingClass = readDeclAs<CXXRecordDecl>();
2045 }
2046 
2047 void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {
2048  VisitExpr(E);
2049  E->TypeTraitExprBits.NumArgs = Record.readInt();
2050  E->TypeTraitExprBits.Kind = Record.readInt();
2051  E->TypeTraitExprBits.Value = Record.readInt();
2052  SourceRange Range = readSourceRange();
2053  E->Loc = Range.getBegin();
2054  E->RParenLoc = Range.getEnd();
2055 
2056  auto **Args = E->getTrailingObjects<TypeSourceInfo *>();
2057  for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
2058  Args[I] = readTypeSourceInfo();
2059 }
2060 
2061 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
2062  VisitExpr(E);
2063  E->ATT = (ArrayTypeTrait)Record.readInt();
2064  E->Value = (unsigned int)Record.readInt();
2065  SourceRange Range = readSourceRange();
2066  E->Loc = Range.getBegin();
2067  E->RParen = Range.getEnd();
2068  E->QueriedType = readTypeSourceInfo();
2069  E->Dimension = Record.readSubExpr();
2070 }
2071 
2072 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
2073  VisitExpr(E);
2074  E->ET = (ExpressionTrait)Record.readInt();
2075  E->Value = (bool)Record.readInt();
2076  SourceRange Range = readSourceRange();
2077  E->QueriedExpression = Record.readSubExpr();
2078  E->Loc = Range.getBegin();
2079  E->RParen = Range.getEnd();
2080 }
2081 
2082 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
2083  VisitExpr(E);
2084  E->CXXNoexceptExprBits.Value = Record.readInt();
2085  E->Range = readSourceRange();
2086  E->Operand = Record.readSubExpr();
2087 }
2088 
2089 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
2090  VisitExpr(E);
2091  E->EllipsisLoc = readSourceLocation();
2092  E->NumExpansions = Record.readInt();
2093  E->Pattern = Record.readSubExpr();
2094 }
2095 
2096 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
2097  VisitExpr(E);
2098  unsigned NumPartialArgs = Record.readInt();
2099  E->OperatorLoc = readSourceLocation();
2100  E->PackLoc = readSourceLocation();
2101  E->RParenLoc = readSourceLocation();
2102  E->Pack = Record.readDeclAs<NamedDecl>();
2103  if (E->isPartiallySubstituted()) {
2104  assert(E->Length == NumPartialArgs);
2105  for (auto *I = E->getTrailingObjects<TemplateArgument>(),
2106  *E = I + NumPartialArgs;
2107  I != E; ++I)
2108  new (I) TemplateArgument(Record.readTemplateArgument());
2109  } else if (!E->isValueDependent()) {
2110  E->Length = Record.readInt();
2111  }
2112 }
2113 
2114 void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(
2116  VisitExpr(E);
2117  E->AssociatedDeclAndRef.setPointer(readDeclAs<Decl>());
2118  E->AssociatedDeclAndRef.setInt(Record.readInt());
2119  E->Index = Record.readInt();
2120  E->PackIndex = Record.readInt();
2121  E->SubstNonTypeTemplateParmExprBits.NameLoc = readSourceLocation();
2122  E->Replacement = Record.readSubExpr();
2123 }
2124 
2125 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
2127  VisitExpr(E);
2128  E->AssociatedDecl = readDeclAs<Decl>();
2129  E->Index = Record.readInt();
2130  TemplateArgument ArgPack = Record.readTemplateArgument();
2131  if (ArgPack.getKind() != TemplateArgument::Pack)
2132  return;
2133 
2134  E->Arguments = ArgPack.pack_begin();
2135  E->NumArguments = ArgPack.pack_size();
2136  E->NameLoc = readSourceLocation();
2137 }
2138 
2139 void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
2140  VisitExpr(E);
2141  E->NumParameters = Record.readInt();
2142  E->ParamPack = readDeclAs<ParmVarDecl>();
2143  E->NameLoc = readSourceLocation();
2144  auto **Parms = E->getTrailingObjects<VarDecl *>();
2145  for (unsigned i = 0, n = E->NumParameters; i != n; ++i)
2146  Parms[i] = readDeclAs<VarDecl>();
2147 }
2148 
2149 void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
2150  VisitExpr(E);
2151  bool HasMaterialzedDecl = Record.readInt();
2152  if (HasMaterialzedDecl)
2153  E->State = cast<LifetimeExtendedTemporaryDecl>(Record.readDecl());
2154  else
2155  E->State = Record.readSubExpr();
2156 }
2157 
2158 void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {
2159  VisitExpr(E);
2160  E->LParenLoc = readSourceLocation();
2161  E->EllipsisLoc = readSourceLocation();
2162  E->RParenLoc = readSourceLocation();
2163  E->NumExpansions = Record.readInt();
2164  E->SubExprs[0] = Record.readSubExpr();
2165  E->SubExprs[1] = Record.readSubExpr();
2166  E->SubExprs[2] = Record.readSubExpr();
2167  E->Opcode = (BinaryOperatorKind)Record.readInt();
2168 }
2169 
2170 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
2171  VisitExpr(E);
2172  E->SourceExpr = Record.readSubExpr();
2173  E->OpaqueValueExprBits.Loc = readSourceLocation();
2174  E->setIsUnique(Record.readInt());
2175 }
2176 
2177 void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {
2178  llvm_unreachable("Cannot read TypoExpr nodes");
2179 }
2180 
2181 void ASTStmtReader::VisitRecoveryExpr(RecoveryExpr *E) {
2182  VisitExpr(E);
2183  unsigned NumArgs = Record.readInt();
2184  E->BeginLoc = readSourceLocation();
2185  E->EndLoc = readSourceLocation();
2186  assert((NumArgs + 0LL ==
2187  std::distance(E->children().begin(), E->children().end())) &&
2188  "Wrong NumArgs!");
2189  (void)NumArgs;
2190  for (Stmt *&Child : E->children())
2191  Child = Record.readSubStmt();
2192 }
2193 
2194 //===----------------------------------------------------------------------===//
2195 // Microsoft Expressions and Statements
2196 //===----------------------------------------------------------------------===//
2197 void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
2198  VisitExpr(E);
2199  E->IsArrow = (Record.readInt() != 0);
2200  E->BaseExpr = Record.readSubExpr();
2201  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2202  E->MemberLoc = readSourceLocation();
2203  E->TheDecl = readDeclAs<MSPropertyDecl>();
2204 }
2205 
2206 void ASTStmtReader::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
2207  VisitExpr(E);
2208  E->setBase(Record.readSubExpr());
2209  E->setIdx(Record.readSubExpr());
2210  E->setRBracketLoc(readSourceLocation());
2211 }
2212 
2213 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
2214  VisitExpr(E);
2215  E->setSourceRange(readSourceRange());
2216  E->Guid = readDeclAs<MSGuidDecl>();
2217  if (E->isTypeOperand())
2218  E->Operand = readTypeSourceInfo();
2219  else
2220  E->Operand = Record.readSubExpr();
2221 }
2222 
2223 void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
2224  VisitStmt(S);
2225  S->setLeaveLoc(readSourceLocation());
2226 }
2227 
2228 void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {
2229  VisitStmt(S);
2230  S->Loc = readSourceLocation();
2231  S->Children[SEHExceptStmt::FILTER_EXPR] = Record.readSubStmt();
2232  S->Children[SEHExceptStmt::BLOCK] = Record.readSubStmt();
2233 }
2234 
2235 void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
2236  VisitStmt(S);
2237  S->Loc = readSourceLocation();
2238  S->Block = Record.readSubStmt();
2239 }
2240 
2241 void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {
2242  VisitStmt(S);
2243  S->IsCXXTry = Record.readInt();
2244  S->TryLoc = readSourceLocation();
2245  S->Children[SEHTryStmt::TRY] = Record.readSubStmt();
2246  S->Children[SEHTryStmt::HANDLER] = Record.readSubStmt();
2247 }
2248 
2249 //===----------------------------------------------------------------------===//
2250 // CUDA Expressions and Statements
2251 //===----------------------------------------------------------------------===//
2252 
2253 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
2254  VisitCallExpr(E);
2255  E->setPreArg(CUDAKernelCallExpr::CONFIG, Record.readSubExpr());
2256 }
2257 
2258 //===----------------------------------------------------------------------===//
2259 // OpenCL Expressions and Statements.
2260 //===----------------------------------------------------------------------===//
2261 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
2262  VisitExpr(E);
2263  E->BuiltinLoc = readSourceLocation();
2264  E->RParenLoc = readSourceLocation();
2265  E->SrcExpr = Record.readSubExpr();
2266 }
2267 
2268 //===----------------------------------------------------------------------===//
2269 // OpenMP Directives.
2270 //===----------------------------------------------------------------------===//
2271 
2272 void ASTStmtReader::VisitOMPCanonicalLoop(OMPCanonicalLoop *S) {
2273  VisitStmt(S);
2274  for (Stmt *&SubStmt : S->SubStmts)
2275  SubStmt = Record.readSubStmt();
2276 }
2277 
2278 void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2279  Record.readOMPChildren(E->Data);
2280  E->setLocStart(readSourceLocation());
2281  E->setLocEnd(readSourceLocation());
2282 }
2283 
2284 void ASTStmtReader::VisitOMPLoopBasedDirective(OMPLoopBasedDirective *D) {
2285  VisitStmt(D);
2286  // Field CollapsedNum was read in ReadStmtFromStream.
2287  Record.skipInts(1);
2288  VisitOMPExecutableDirective(D);
2289 }
2290 
2291 void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) {
2292  VisitOMPLoopBasedDirective(D);
2293 }
2294 
2295 void ASTStmtReader::VisitOMPMetaDirective(OMPMetaDirective *D) {
2296  VisitStmt(D);
2297  // The NumClauses field was read in ReadStmtFromStream.
2298  Record.skipInts(1);
2299  VisitOMPExecutableDirective(D);
2300 }
2301 
2302 void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) {
2303  VisitStmt(D);
2304  VisitOMPExecutableDirective(D);
2305  D->setHasCancel(Record.readBool());
2306 }
2307 
2308 void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) {
2309  VisitOMPLoopDirective(D);
2310 }
2311 
2312 void ASTStmtReader::VisitOMPLoopTransformationDirective(
2314  VisitOMPLoopBasedDirective(D);
2315  D->setNumGeneratedLoops(Record.readUInt32());
2316 }
2317 
2318 void ASTStmtReader::VisitOMPTileDirective(OMPTileDirective *D) {
2319  VisitOMPLoopTransformationDirective(D);
2320 }
2321 
2322 void ASTStmtReader::VisitOMPUnrollDirective(OMPUnrollDirective *D) {
2323  VisitOMPLoopTransformationDirective(D);
2324 }
2325 
2326 void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) {
2327  VisitOMPLoopDirective(D);
2328  D->setHasCancel(Record.readBool());
2329 }
2330 
2331 void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
2332  VisitOMPLoopDirective(D);
2333 }
2334 
2335 void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
2336  VisitStmt(D);
2337  VisitOMPExecutableDirective(D);
2338  D->setHasCancel(Record.readBool());
2339 }
2340 
2341 void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) {
2342  VisitStmt(D);
2343  VisitOMPExecutableDirective(D);
2344  D->setHasCancel(Record.readBool());
2345 }
2346 
2347 void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) {
2348  VisitStmt(D);
2349  VisitOMPExecutableDirective(D);
2350 }
2351 
2352 void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) {
2353  VisitStmt(D);
2354  VisitOMPExecutableDirective(D);
2355 }
2356 
2357 void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2358  VisitStmt(D);
2359  VisitOMPExecutableDirective(D);
2360  D->DirName = Record.readDeclarationNameInfo();
2361 }
2362 
2363 void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2364  VisitOMPLoopDirective(D);
2365  D->setHasCancel(Record.readBool());
2366 }
2367 
2368 void ASTStmtReader::VisitOMPParallelForSimdDirective(
2370  VisitOMPLoopDirective(D);
2371 }
2372 
2373 void ASTStmtReader::VisitOMPParallelMasterDirective(
2375  VisitStmt(D);
2376  VisitOMPExecutableDirective(D);
2377 }
2378 
2379 void ASTStmtReader::VisitOMPParallelMaskedDirective(
2381  VisitStmt(D);
2382  VisitOMPExecutableDirective(D);
2383 }
2384 
2385 void ASTStmtReader::VisitOMPParallelSectionsDirective(
2387  VisitStmt(D);
2388  VisitOMPExecutableDirective(D);
2389  D->setHasCancel(Record.readBool());
2390 }
2391 
2392 void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) {
2393  VisitStmt(D);
2394  VisitOMPExecutableDirective(D);
2395  D->setHasCancel(Record.readBool());
2396 }
2397 
2398 void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2399  VisitStmt(D);
2400  VisitOMPExecutableDirective(D);
2401 }
2402 
2403 void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2404  VisitStmt(D);
2405  VisitOMPExecutableDirective(D);
2406 }
2407 
2408 void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2409  VisitStmt(D);
2410  // The NumClauses field was read in ReadStmtFromStream.
2411  Record.skipInts(1);
2412  VisitOMPExecutableDirective(D);
2413 }
2414 
2415 void ASTStmtReader::VisitOMPErrorDirective(OMPErrorDirective *D) {
2416  VisitStmt(D);
2417  // The NumClauses field was read in ReadStmtFromStream.
2418  Record.skipInts(1);
2419  VisitOMPExecutableDirective(D);
2420 }
2421 
2422 void ASTStmtReader::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
2423  VisitStmt(D);
2424  VisitOMPExecutableDirective(D);
2425 }
2426 
2427 void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) {
2428  VisitStmt(D);
2429  VisitOMPExecutableDirective(D);
2430 }
2431 
2432 void ASTStmtReader::VisitOMPDepobjDirective(OMPDepobjDirective *D) {
2433  VisitStmt(D);
2434  VisitOMPExecutableDirective(D);
2435 }
2436 
2437 void ASTStmtReader::VisitOMPScanDirective(OMPScanDirective *D) {
2438  VisitStmt(D);
2439  VisitOMPExecutableDirective(D);
2440 }
2441 
2442 void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
2443  VisitStmt(D);
2444  VisitOMPExecutableDirective(D);
2445 }
2446 
2447 void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
2448  VisitStmt(D);
2449  VisitOMPExecutableDirective(D);
2450  D->Flags.IsXLHSInRHSPart = Record.readBool() ? 1 : 0;
2451  D->Flags.IsPostfixUpdate = Record.readBool() ? 1 : 0;
2452  D->Flags.IsFailOnly = Record.readBool() ? 1 : 0;
2453 }
2454 
2455 void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) {
2456  VisitStmt(D);
2457  VisitOMPExecutableDirective(D);
2458 }
2459 
2460 void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
2461  VisitStmt(D);
2462  VisitOMPExecutableDirective(D);
2463 }
2464 
2465 void ASTStmtReader::VisitOMPTargetEnterDataDirective(
2467  VisitStmt(D);
2468  VisitOMPExecutableDirective(D);
2469 }
2470 
2471 void ASTStmtReader::VisitOMPTargetExitDataDirective(
2473  VisitStmt(D);
2474  VisitOMPExecutableDirective(D);
2475 }
2476 
2477 void ASTStmtReader::VisitOMPTargetParallelDirective(
2479  VisitStmt(D);
2480  VisitOMPExecutableDirective(D);
2481  D->setHasCancel(Record.readBool());
2482 }
2483 
2484 void ASTStmtReader::VisitOMPTargetParallelForDirective(
2486  VisitOMPLoopDirective(D);
2487  D->setHasCancel(Record.readBool());
2488 }
2489 
2490 void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2491  VisitStmt(D);
2492  VisitOMPExecutableDirective(D);
2493 }
2494 
2495 void ASTStmtReader::VisitOMPCancellationPointDirective(
2497  VisitStmt(D);
2498  VisitOMPExecutableDirective(D);
2499  D->setCancelRegion(Record.readEnum<OpenMPDirectiveKind>());
2500 }
2501 
2502 void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) {
2503  VisitStmt(D);
2504  VisitOMPExecutableDirective(D);
2505  D->setCancelRegion(Record.readEnum<OpenMPDirectiveKind>());
2506 }
2507 
2508 void ASTStmtReader::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
2509  VisitOMPLoopDirective(D);
2510  D->setHasCancel(Record.readBool());
2511 }
2512 
2513 void ASTStmtReader::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
2514  VisitOMPLoopDirective(D);
2515 }
2516 
2517 void ASTStmtReader::VisitOMPMasterTaskLoopDirective(
2519  VisitOMPLoopDirective(D);
2520  D->setHasCancel(Record.readBool());
2521 }
2522 
2523 void ASTStmtReader::VisitOMPMaskedTaskLoopDirective(
2525  VisitOMPLoopDirective(D);
2526  D->setHasCancel(Record.readBool());
2527 }
2528 
2529 void ASTStmtReader::VisitOMPMasterTaskLoopSimdDirective(
2531  VisitOMPLoopDirective(D);
2532 }
2533 
2534 void ASTStmtReader::VisitOMPMaskedTaskLoopSimdDirective(
2536  VisitOMPLoopDirective(D);
2537 }
2538 
2539 void ASTStmtReader::VisitOMPParallelMasterTaskLoopDirective(
2541  VisitOMPLoopDirective(D);
2542  D->setHasCancel(Record.readBool());
2543 }
2544 
2545 void ASTStmtReader::VisitOMPParallelMaskedTaskLoopDirective(
2547  VisitOMPLoopDirective(D);
2548  D->setHasCancel(Record.readBool());
2549 }
2550 
2551 void ASTStmtReader::VisitOMPParallelMasterTaskLoopSimdDirective(
2553  VisitOMPLoopDirective(D);
2554 }
2555 
2556 void ASTStmtReader::VisitOMPParallelMaskedTaskLoopSimdDirective(
2558  VisitOMPLoopDirective(D);
2559 }
2560 
2561 void ASTStmtReader::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
2562  VisitOMPLoopDirective(D);
2563 }
2564 
2565 void ASTStmtReader::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) {
2566  VisitStmt(D);
2567  VisitOMPExecutableDirective(D);
2568 }
2569 
2570 void ASTStmtReader::VisitOMPDistributeParallelForDirective(
2572  VisitOMPLoopDirective(D);
2573  D->setHasCancel(Record.readBool());
2574 }
2575 
2576 void ASTStmtReader::VisitOMPDistributeParallelForSimdDirective(
2578  VisitOMPLoopDirective(D);
2579 }
2580 
2581 void ASTStmtReader::VisitOMPDistributeSimdDirective(
2583  VisitOMPLoopDirective(D);
2584 }
2585 
2586 void ASTStmtReader::VisitOMPTargetParallelForSimdDirective(
2588  VisitOMPLoopDirective(D);
2589 }
2590 
2591 void ASTStmtReader::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) {
2592  VisitOMPLoopDirective(D);
2593 }
2594 
2595 void ASTStmtReader::VisitOMPTeamsDistributeDirective(
2597  VisitOMPLoopDirective(D);
2598 }
2599 
2600 void ASTStmtReader::VisitOMPTeamsDistributeSimdDirective(
2602  VisitOMPLoopDirective(D);
2603 }
2604 
2605 void ASTStmtReader::VisitOMPTeamsDistributeParallelForSimdDirective(
2607  VisitOMPLoopDirective(D);
2608 }
2609 
2610 void ASTStmtReader::VisitOMPTeamsDistributeParallelForDirective(
2612  VisitOMPLoopDirective(D);
2613  D->setHasCancel(Record.readBool());
2614 }
2615 
2616 void ASTStmtReader::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) {
2617  VisitStmt(D);
2618  VisitOMPExecutableDirective(D);
2619 }
2620 
2621 void ASTStmtReader::VisitOMPTargetTeamsDistributeDirective(
2623  VisitOMPLoopDirective(D);
2624 }
2625 
2626 void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForDirective(
2628  VisitOMPLoopDirective(D);
2629  D->setHasCancel(Record.readBool());
2630 }
2631 
2632 void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
2634  VisitOMPLoopDirective(D);
2635 }
2636 
2637 void ASTStmtReader::VisitOMPTargetTeamsDistributeSimdDirective(
2639  VisitOMPLoopDirective(D);
2640 }
2641 
2642 void ASTStmtReader::VisitOMPInteropDirective(OMPInteropDirective *D) {
2643  VisitStmt(D);
2644  VisitOMPExecutableDirective(D);
2645 }
2646 
2647 void ASTStmtReader::VisitOMPDispatchDirective(OMPDispatchDirective *D) {
2648  VisitStmt(D);
2649  VisitOMPExecutableDirective(D);
2650  D->setTargetCallLoc(Record.readSourceLocation());
2651 }
2652 
2653 void ASTStmtReader::VisitOMPMaskedDirective(OMPMaskedDirective *D) {
2654  VisitStmt(D);
2655  VisitOMPExecutableDirective(D);
2656 }
2657 
2658 void ASTStmtReader::VisitOMPGenericLoopDirective(OMPGenericLoopDirective *D) {
2659  VisitOMPLoopDirective(D);
2660 }
2661 
2662 void ASTStmtReader::VisitOMPTeamsGenericLoopDirective(
2664  VisitOMPLoopDirective(D);
2665 }
2666 
2667 void ASTStmtReader::VisitOMPTargetTeamsGenericLoopDirective(
2669  VisitOMPLoopDirective(D);
2670 }
2671 
2672 void ASTStmtReader::VisitOMPParallelGenericLoopDirective(
2674  VisitOMPLoopDirective(D);
2675 }
2676 
2677 void ASTStmtReader::VisitOMPTargetParallelGenericLoopDirective(
2679  VisitOMPLoopDirective(D);
2680 }
2681 
2682 //===----------------------------------------------------------------------===//
2683 // ASTReader Implementation
2684 //===----------------------------------------------------------------------===//
2685 
2687  switch (ReadingKind) {
2688  case Read_None:
2689  llvm_unreachable("should not call this when not reading anything");
2690  case Read_Decl:
2691  case Read_Type:
2692  return ReadStmtFromStream(F);
2693  case Read_Stmt:
2694  return ReadSubStmt();
2695  }
2696 
2697  llvm_unreachable("ReadingKind not set ?");
2698 }
2699 
2701  return cast_or_null<Expr>(ReadStmt(F));
2702 }
2703 
2705  return cast_or_null<Expr>(ReadSubStmt());
2706 }
2707 
2708 // Within the bitstream, expressions are stored in Reverse Polish
2709 // Notation, with each of the subexpressions preceding the
2710 // expression they are stored in. Subexpressions are stored from last to first.
2711 // To evaluate expressions, we continue reading expressions and placing them on
2712 // the stack, with expressions having operands removing those operands from the
2713 // stack. Evaluation terminates when we see a STMT_STOP record, and
2714 // the single remaining expression on the stack is our result.
2715 Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
2716  ReadingKindTracker ReadingKind(Read_Stmt, *this);
2717  llvm::BitstreamCursor &Cursor = F.DeclsCursor;
2718 
2719  // Map of offset to previously deserialized stmt. The offset points
2720  // just after the stmt record.
2721  llvm::DenseMap<uint64_t, Stmt *> StmtEntries;
2722 
2723 #ifndef NDEBUG
2724  unsigned PrevNumStmts = StmtStack.size();
2725 #endif
2726 
2727  ASTRecordReader Record(*this, F);
2728  ASTStmtReader Reader(Record, Cursor);
2729  Stmt::EmptyShell Empty;
2730 
2731  while (true) {
2733  Cursor.advanceSkippingSubblocks();
2734  if (!MaybeEntry) {
2735  Error(toString(MaybeEntry.takeError()));
2736  return nullptr;
2737  }
2738  llvm::BitstreamEntry Entry = MaybeEntry.get();
2739 
2740  switch (Entry.Kind) {
2741  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
2743  Error("malformed block record in AST file");
2744  return nullptr;
2745  case llvm::BitstreamEntry::EndBlock:
2746  goto Done;
2747  case llvm::BitstreamEntry::Record:
2748  // The interesting case.
2749  break;
2750  }
2751 
2752  ASTContext &Context = getContext();
2753  Stmt *S = nullptr;
2754  bool Finished = false;
2755  bool IsStmtReference = false;
2756  Expected<unsigned> MaybeStmtCode = Record.readRecord(Cursor, Entry.ID);
2757  if (!MaybeStmtCode) {
2758  Error(toString(MaybeStmtCode.takeError()));
2759  return nullptr;
2760  }
2761  switch ((StmtCode)MaybeStmtCode.get()) {
2762  case STMT_STOP:
2763  Finished = true;
2764  break;
2765 
2766  case STMT_REF_PTR:
2767  IsStmtReference = true;
2768  assert(StmtEntries.find(Record[0]) != StmtEntries.end() &&
2769  "No stmt was recorded for this offset reference!");
2770  S = StmtEntries[Record.readInt()];
2771  break;
2772 
2773  case STMT_NULL_PTR:
2774  S = nullptr;
2775  break;
2776 
2777  case STMT_NULL:
2778  S = new (Context) NullStmt(Empty);
2779  break;
2780 
2781  case STMT_COMPOUND:
2783  Context, /*NumStmts=*/Record[ASTStmtReader::NumStmtFields],
2784  /*HasFPFeatures=*/Record[ASTStmtReader::NumStmtFields + 1]);
2785  break;
2786 
2787  case STMT_CASE:
2789  Context,
2790  /*CaseStmtIsGNURange*/ Record[ASTStmtReader::NumStmtFields + 3]);
2791  break;
2792 
2793  case STMT_DEFAULT:
2794  S = new (Context) DefaultStmt(Empty);
2795  break;
2796 
2797  case STMT_LABEL:
2798  S = new (Context) LabelStmt(Empty);
2799  break;
2800 
2801  case STMT_ATTRIBUTED:
2803  Context,
2804  /*NumAttrs*/Record[ASTStmtReader::NumStmtFields]);
2805  break;
2806 
2807  case STMT_IF:
2808  S = IfStmt::CreateEmpty(
2809  Context,
2810  /* HasElse=*/Record[ASTStmtReader::NumStmtFields],
2811  /* HasVar=*/Record[ASTStmtReader::NumStmtFields + 1],
2812  /* HasInit=*/Record[ASTStmtReader::NumStmtFields + 2]);
2813  break;
2814 
2815  case STMT_SWITCH:
2817  Context,
2818  /* HasInit=*/Record[ASTStmtReader::NumStmtFields],
2819  /* HasVar=*/Record[ASTStmtReader::NumStmtFields + 1]);
2820  break;
2821 
2822  case STMT_WHILE:
2824  Context,
2825  /* HasVar=*/Record[ASTStmtReader::NumStmtFields]);
2826  break;
2827 
2828  case STMT_DO:
2829  S = new (Context) DoStmt(Empty);
2830  break;
2831 
2832  case STMT_FOR:
2833  S = new (Context) ForStmt(Empty);
2834  break;
2835 
2836  case STMT_GOTO:
2837  S = new (Context) GotoStmt(Empty);
2838  break;
2839 
2840  case STMT_INDIRECT_GOTO:
2841  S = new (Context) IndirectGotoStmt(Empty);
2842  break;
2843 
2844  case STMT_CONTINUE:
2845  S = new (Context) ContinueStmt(Empty);
2846  break;
2847 
2848  case STMT_BREAK:
2849  S = new (Context) BreakStmt(Empty);
2850  break;
2851 
2852  case STMT_RETURN:
2854  Context, /* HasNRVOCandidate=*/Record[ASTStmtReader::NumStmtFields]);
2855  break;
2856 
2857  case STMT_DECL:
2858  S = new (Context) DeclStmt(Empty);
2859  break;
2860 
2861  case STMT_GCCASM:
2862  S = new (Context) GCCAsmStmt(Empty);
2863  break;
2864 
2865  case STMT_MSASM:
2866  S = new (Context) MSAsmStmt(Empty);
2867  break;
2868 
2869  case STMT_CAPTURED:
2871  Context, Record[ASTStmtReader::NumStmtFields]);
2872  break;
2873 
2874  case EXPR_CONSTANT:
2876  Context, static_cast<ConstantExpr::ResultStorageKind>(
2877  /*StorageKind=*/Record[ASTStmtReader::NumExprFields]));
2878  break;
2879 
2882  break;
2883 
2884  case EXPR_PREDEFINED:
2886  Context,
2887  /*HasFunctionName*/ Record[ASTStmtReader::NumExprFields]);
2888  break;
2889 
2890  case EXPR_DECL_REF:
2892  Context,
2893  /*HasQualifier=*/Record[ASTStmtReader::NumExprFields],
2894  /*HasFoundDecl=*/Record[ASTStmtReader::NumExprFields + 1],
2895  /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 2],
2896  /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ?
2897  Record[ASTStmtReader::NumExprFields + 6] : 0);
2898  break;
2899 
2900  case EXPR_INTEGER_LITERAL:
2901  S = IntegerLiteral::Create(Context, Empty);
2902  break;
2903 
2905  S = FixedPointLiteral::Create(Context, Empty);
2906  break;
2907 
2908  case EXPR_FLOATING_LITERAL:
2909  S = FloatingLiteral::Create(Context, Empty);
2910  break;
2911 
2913  S = new (Context) ImaginaryLiteral(Empty);
2914  break;
2915 
2916  case EXPR_STRING_LITERAL:
2918  Context,
2919  /* NumConcatenated=*/Record[ASTStmtReader::NumExprFields],
2920  /* Length=*/Record[ASTStmtReader::NumExprFields + 1],
2921  /* CharByteWidth=*/Record[ASTStmtReader::NumExprFields + 2]);
2922  break;
2923 
2925  S = new (Context) CharacterLiteral(Empty);
2926  break;
2927 
2928  case EXPR_PAREN:
2929  S = new (Context) ParenExpr(Empty);
2930  break;
2931 
2932  case EXPR_PAREN_LIST:
2934  Context,
2935  /* NumExprs=*/Record[ASTStmtReader::NumExprFields]);
2936  break;
2937 
2938  case EXPR_UNARY_OPERATOR:
2939  S = UnaryOperator::CreateEmpty(Context,
2941  break;
2942 
2943  case EXPR_OFFSETOF:
2944  S = OffsetOfExpr::CreateEmpty(Context,
2946  Record[ASTStmtReader::NumExprFields + 1]);
2947  break;
2948 
2949  case EXPR_SIZEOF_ALIGN_OF:
2950  S = new (Context) UnaryExprOrTypeTraitExpr(Empty);
2951  break;
2952 
2953  case EXPR_ARRAY_SUBSCRIPT:
2954  S = new (Context) ArraySubscriptExpr(Empty);
2955  break;
2956 
2957  case EXPR_MATRIX_SUBSCRIPT:
2958  S = new (Context) MatrixSubscriptExpr(Empty);
2959  break;
2960 
2962  S = new (Context) OMPArraySectionExpr(Empty);
2963  break;
2964 
2967  Context, Record[ASTStmtReader::NumExprFields]);
2968  break;
2969 
2970  case EXPR_OMP_ITERATOR:
2971  S = OMPIteratorExpr::CreateEmpty(Context,
2973  break;
2974 
2975  case EXPR_CALL:
2977  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields],
2978  /*HasFPFeatures=*/Record[ASTStmtReader::NumExprFields + 1], Empty);
2979  break;
2980 
2981  case EXPR_RECOVERY:
2983  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
2984  break;
2985 
2986  case EXPR_MEMBER:
2988  Record[ASTStmtReader::NumExprFields + 1],
2989  Record[ASTStmtReader::NumExprFields + 2],
2990  Record[ASTStmtReader::NumExprFields + 3]);
2991  break;
2992 
2993  case EXPR_BINARY_OPERATOR:
2994  S = BinaryOperator::CreateEmpty(Context,
2996  break;
2997 
3000  Context, Record[ASTStmtReader::NumExprFields]);
3001  break;
3002 
3004  S = new (Context) ConditionalOperator(Empty);
3005  break;
3006 
3008  S = new (Context) BinaryConditionalOperator(Empty);
3009  break;
3010 
3011  case EXPR_IMPLICIT_CAST:
3013  Context,
3014  /*PathSize*/ Record[ASTStmtReader::NumExprFields],
3015  /*HasFPFeatures*/ Record[ASTStmtReader::NumExprFields + 1]);
3016  break;
3017 
3018  case EXPR_CSTYLE_CAST:
3020  Context,
3021  /*PathSize*/ Record[ASTStmtReader::NumExprFields],
3022  /*HasFPFeatures*/ Record[ASTStmtReader::NumExprFields + 1]);
3023  break;
3024 
3025  case EXPR_COMPOUND_LITERAL:
3026  S = new (Context) CompoundLiteralExpr(Empty);
3027  break;
3028 
3030  S = new (Context) ExtVectorElementExpr(Empty);
3031  break;
3032 
3033  case EXPR_INIT_LIST:
3034  S = new (Context) InitListExpr(Empty);
3035  break;
3036 
3037  case EXPR_DESIGNATED_INIT:
3038  S = DesignatedInitExpr::CreateEmpty(Context,
3039  Record[ASTStmtReader::NumExprFields] - 1);
3040 
3041  break;
3042 
3044  S = new (Context) DesignatedInitUpdateExpr(Empty);
3045  break;
3046 
3048  S = new (Context) ImplicitValueInitExpr(Empty);
3049  break;
3050 
3051  case EXPR_NO_INIT:
3052  S = new (Context) NoInitExpr(Empty);
3053  break;
3054 
3055  case EXPR_ARRAY_INIT_LOOP:
3056  S = new (Context) ArrayInitLoopExpr(Empty);
3057  break;
3058 
3059  case EXPR_ARRAY_INIT_INDEX:
3060  S = new (Context) ArrayInitIndexExpr(Empty);
3061  break;
3062 
3063  case EXPR_VA_ARG:
3064  S = new (Context) VAArgExpr(Empty);
3065  break;
3066 
3067  case EXPR_SOURCE_LOC:
3068  S = new (Context) SourceLocExpr(Empty);
3069  break;
3070 
3071  case EXPR_ADDR_LABEL:
3072  S = new (Context) AddrLabelExpr(Empty);
3073  break;
3074 
3075  case EXPR_STMT:
3076  S = new (Context) StmtExpr(Empty);
3077  break;
3078 
3079  case EXPR_CHOOSE:
3080  S = new (Context) ChooseExpr(Empty);
3081  break;
3082 
3083  case EXPR_GNU_NULL:
3084  S = new (Context) GNUNullExpr(Empty);
3085  break;
3086 
3087  case EXPR_SHUFFLE_VECTOR:
3088  S = new (Context) ShuffleVectorExpr(Empty);
3089  break;
3090 
3091  case EXPR_CONVERT_VECTOR:
3092  S = new (Context) ConvertVectorExpr(Empty);
3093  break;
3094 
3095  case EXPR_BLOCK:
3096  S = new (Context) BlockExpr(Empty);
3097  break;
3098 
3101  Context,
3102  /*NumAssocs=*/Record[ASTStmtReader::NumExprFields]);
3103  break;
3104 
3106  S = new (Context) ObjCStringLiteral(Empty);
3107  break;
3108 
3110  S = new (Context) ObjCBoxedExpr(Empty);
3111  break;
3112 
3114  S = ObjCArrayLiteral::CreateEmpty(Context,
3116  break;
3117 
3121  Record[ASTStmtReader::NumExprFields + 1]);
3122  break;
3123 
3124  case EXPR_OBJC_ENCODE:
3125  S = new (Context) ObjCEncodeExpr(Empty);
3126  break;
3127 
3129  S = new (Context) ObjCSelectorExpr(Empty);
3130  break;
3131 
3133  S = new (Context) ObjCProtocolExpr(Empty);
3134  break;
3135 
3137  S = new (Context) ObjCIvarRefExpr(Empty);
3138  break;
3139 
3141  S = new (Context) ObjCPropertyRefExpr(Empty);
3142  break;
3143 
3145  S = new (Context) ObjCSubscriptRefExpr(Empty);
3146  break;
3147 
3149  llvm_unreachable("mismatching AST file");
3150 
3152  S = ObjCMessageExpr::CreateEmpty(Context,
3154  Record[ASTStmtReader::NumExprFields + 1]);
3155  break;
3156 
3157  case EXPR_OBJC_ISA:
3158  S = new (Context) ObjCIsaExpr(Empty);
3159  break;
3160 
3162  S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);
3163  break;
3164 
3166  S = new (Context) ObjCBridgedCastExpr(Empty);
3167  break;
3168 
3170  S = new (Context) ObjCForCollectionStmt(Empty);
3171  break;
3172 
3173  case STMT_OBJC_CATCH:
3174  S = new (Context) ObjCAtCatchStmt(Empty);
3175  break;
3176 
3177  case STMT_OBJC_FINALLY:
3178  S = new (Context) ObjCAtFinallyStmt(Empty);
3179  break;
3180 
3181  case STMT_OBJC_AT_TRY:
3182  S = ObjCAtTryStmt::CreateEmpty(Context,
3184  Record[ASTStmtReader::NumStmtFields + 1]);
3185  break;
3186 
3188  S = new (Context) ObjCAtSynchronizedStmt(Empty);
3189  break;
3190 
3191  case STMT_OBJC_AT_THROW:
3192  S = new (Context) ObjCAtThrowStmt(Empty);
3193  break;
3194 
3196  S = new (Context) ObjCAutoreleasePoolStmt(Empty);
3197  break;
3198 
3200  S = new (Context) ObjCBoolLiteralExpr(Empty);
3201  break;
3202 
3204  S = new (Context) ObjCAvailabilityCheckExpr(Empty);
3205  break;
3206 
3207  case STMT_SEH_LEAVE:
3208  S = new (Context) SEHLeaveStmt(Empty);
3209  break;
3210 
3211  case STMT_SEH_EXCEPT:
3212  S = new (Context) SEHExceptStmt(Empty);
3213  break;
3214 
3215  case STMT_SEH_FINALLY:
3216  S = new (Context) SEHFinallyStmt(Empty);
3217  break;
3218 
3219  case STMT_SEH_TRY:
3220  S = new (Context) SEHTryStmt(Empty);
3221  break;
3222 
3223  case STMT_CXX_CATCH:
3224  S = new (Context) CXXCatchStmt(Empty);
3225  break;
3226 
3227  case STMT_CXX_TRY:
3228  S = CXXTryStmt::Create(Context, Empty,
3229  /*numHandlers=*/Record[ASTStmtReader::NumStmtFields]);
3230  break;
3231 
3232  case STMT_CXX_FOR_RANGE:
3233  S = new (Context) CXXForRangeStmt(Empty);
3234  break;
3235 
3237  S = new (Context) MSDependentExistsStmt(SourceLocation(), true,
3240  nullptr);
3241  break;
3242 
3244  S = OMPCanonicalLoop::createEmpty(Context);
3245  break;
3246 
3249  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3250  break;
3251 
3253  S =
3256  Empty);
3257  break;
3258 
3259  case STMT_OMP_SIMD_DIRECTIVE: {
3260  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3261  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3262  S = OMPSimdDirective::CreateEmpty(Context, NumClauses,
3263  CollapsedNum, Empty);
3264  break;
3265  }
3266 
3267  case STMT_OMP_TILE_DIRECTIVE: {
3268  unsigned NumLoops = Record[ASTStmtReader::NumStmtFields];
3269  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3270  S = OMPTileDirective::CreateEmpty(Context, NumClauses, NumLoops);
3271  break;
3272  }
3273 
3275  assert(Record[ASTStmtReader::NumStmtFields] == 1 && "Unroll directive accepts only a single loop");
3276  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3277  S = OMPUnrollDirective::CreateEmpty(Context, NumClauses);
3278  break;
3279  }
3280 
3281  case STMT_OMP_FOR_DIRECTIVE: {
3282  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3283  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3284  S = OMPForDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3285  Empty);
3286  break;
3287  }
3288 
3290  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3291  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3292  S = OMPForSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3293  Empty);
3294  break;
3295  }
3296 
3299  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3300  break;
3301 
3303  S = OMPSectionDirective::CreateEmpty(Context, Empty);
3304  break;
3305 
3308  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3309  break;
3310 
3312  S = OMPMasterDirective::CreateEmpty(Context, Empty);
3313  break;
3314 
3317  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3318  break;
3319 
3321  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3322  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3323  S = OMPParallelForDirective::CreateEmpty(Context, NumClauses,
3324  CollapsedNum, Empty);
3325  break;
3326  }
3327 
3329  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3330  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3331  S = OMPParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3332  CollapsedNum, Empty);
3333  break;
3334  }
3335 
3338  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3339  break;
3340 
3343  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3344  break;
3345 
3348  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3349  break;
3350 
3353  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3354  break;
3355 
3357  S = OMPTaskyieldDirective::CreateEmpty(Context, Empty);
3358  break;
3359 
3361  S = OMPBarrierDirective::CreateEmpty(Context, Empty);
3362  break;
3363 
3366  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3367  break;
3368 
3371  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3372  break;
3373 
3376  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3377  break;
3378 
3381  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3382  break;
3383 
3386  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3387  break;
3388 
3391  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3392  break;
3393 
3395  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3396  bool HasAssociatedStmt = Record[ASTStmtReader::NumStmtFields + 2];
3397  S = OMPOrderedDirective::CreateEmpty(Context, NumClauses,
3398  !HasAssociatedStmt, Empty);
3399  break;
3400  }
3401 
3404  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3405  break;
3406 
3409  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3410  break;
3411 
3414  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3415  break;
3416 
3419  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3420  break;
3421 
3424  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3425  break;
3426 
3429  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3430  break;
3431 
3433  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3434  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3435  S = OMPTargetParallelForDirective::CreateEmpty(Context, NumClauses,
3436  CollapsedNum, Empty);
3437  break;
3438  }
3439 
3442  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3443  break;
3444 
3447  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3448  break;
3449 
3451  S = OMPCancellationPointDirective::CreateEmpty(Context, Empty);
3452  break;
3453 
3456  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3457  break;
3458 
3460  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3461  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3462  S = OMPTaskLoopDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3463  Empty);
3464  break;
3465  }
3466 
3468  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3469  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3470  S = OMPTaskLoopSimdDirective::CreateEmpty(Context, NumClauses,
3471  CollapsedNum, Empty);
3472  break;
3473  }
3474 
3476  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3477  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3478  S = OMPMasterTaskLoopDirective::CreateEmpty(Context, NumClauses,
3479  CollapsedNum, Empty);
3480  break;
3481  }
3482 
3484  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3485  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3486  S = OMPMaskedTaskLoopDirective::CreateEmpty(Context, NumClauses,
3487  CollapsedNum, Empty);
3488  break;
3489  }
3490 
3492  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3493  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3494  S = OMPMasterTaskLoopSimdDirective::CreateEmpty(Context, NumClauses,
3495  CollapsedNum, Empty);
3496  break;
3497  }
3498 
3500  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3501  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3502  S = OMPMaskedTaskLoopSimdDirective::CreateEmpty(Context, NumClauses,
3503  CollapsedNum, Empty);
3504  break;
3505  }
3506 
3508  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3509  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3510  S = OMPParallelMasterTaskLoopDirective::CreateEmpty(Context, NumClauses,
3511  CollapsedNum, Empty);
3512  break;
3513  }
3514 
3516  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3517  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3518  S = OMPParallelMaskedTaskLoopDirective::CreateEmpty(Context, NumClauses,
3519  CollapsedNum, Empty);
3520  break;
3521  }
3522 
3524  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3525  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3527  Context, NumClauses, CollapsedNum, Empty);
3528  break;
3529  }
3530 
3532  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3533  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3535  Context, NumClauses, CollapsedNum, Empty);
3536  break;
3537  }
3538 
3540  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3541  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3542  S = OMPDistributeDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3543  Empty);
3544  break;
3545  }
3546 
3548  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3549  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3550  S = OMPDistributeParallelForDirective::CreateEmpty(Context, NumClauses,
3551  CollapsedNum, Empty);
3552  break;
3553  }
3554 
3556  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3557  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3559  CollapsedNum,
3560  Empty);
3561  break;
3562  }
3563 
3565  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3566  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3567  S = OMPDistributeSimdDirective::CreateEmpty(Context, NumClauses,
3568  CollapsedNum, Empty);
3569  break;
3570  }
3571 
3573  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3574  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3575  S = OMPTargetParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3576  CollapsedNum, Empty);
3577  break;
3578  }
3579 
3581  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3582  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3583  S = OMPTargetSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3584  Empty);
3585  break;
3586  }
3587 
3589  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3590  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3591  S = OMPTeamsDistributeDirective::CreateEmpty(Context, NumClauses,
3592  CollapsedNum, Empty);
3593  break;
3594  }
3595 
3597  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3598  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3599  S = OMPTeamsDistributeSimdDirective::CreateEmpty(Context, NumClauses,
3600  CollapsedNum, Empty);
3601  break;
3602  }
3603 
3605  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3606  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3608  Context, NumClauses, CollapsedNum, Empty);
3609  break;
3610  }
3611 
3613  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3614  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3616  Context, NumClauses, CollapsedNum, Empty);
3617  break;
3618  }
3619 
3622  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3623  break;
3624 
3626  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3627  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3628  S = OMPTargetTeamsDistributeDirective::CreateEmpty(Context, NumClauses,
3629  CollapsedNum, Empty);
3630  break;
3631  }
3632 
3634  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3635  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3637  Context, NumClauses, CollapsedNum, Empty);
3638  break;
3639  }
3640 
3642  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3643  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3645  Context, NumClauses, CollapsedNum, Empty);
3646  break;
3647  }
3648 
3650  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3651  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3653  Context, NumClauses, CollapsedNum, Empty);
3654  break;
3655  }
3656 
3659  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3660  break;
3661 
3664  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3665  break;
3666 
3669  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3670  break;
3671 
3673  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3674  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3675  S = OMPGenericLoopDirective::CreateEmpty(Context, NumClauses,
3676  CollapsedNum, Empty);
3677  break;
3678  }
3679 
3681  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3682  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3683  S = OMPTeamsGenericLoopDirective::CreateEmpty(Context, NumClauses,
3684  CollapsedNum, Empty);
3685  break;
3686  }
3687 
3689  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3690  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3691  S = OMPTargetTeamsGenericLoopDirective::CreateEmpty(Context, NumClauses,
3692  CollapsedNum, Empty);
3693  break;
3694  }
3695 
3697  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3698  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3699  S = OMPParallelGenericLoopDirective::CreateEmpty(Context, NumClauses,
3700  CollapsedNum, Empty);
3701  break;
3702  }
3703 
3705  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3706  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3708  Context, NumClauses, CollapsedNum, Empty);
3709  break;
3710  }
3711 
3714  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields],
3715  /*HasFPFeatures=*/Record[ASTStmtReader::NumExprFields + 1], Empty);
3716  break;
3717 
3718  case EXPR_CXX_MEMBER_CALL:
3720  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields],
3721  /*HasFPFeatures=*/Record[ASTStmtReader::NumExprFields + 1], Empty);
3722  break;
3723 
3725  S = new (Context) CXXRewrittenBinaryOperator(Empty);
3726  break;
3727 
3728  case EXPR_CXX_CONSTRUCT:
3730  Context,
3731  /* NumArgs=*/Record[ASTStmtReader::NumExprFields]);
3732  break;
3733 
3735  S = new (Context) CXXInheritedCtorInitExpr(Empty);
3736  break;
3737 
3740  Context,
3741  /* NumArgs=*/Record[ASTStmtReader::NumExprFields]);
3742  break;
3743 
3744  case EXPR_CXX_STATIC_CAST:
3746  Context,
3747  /*PathSize*/ Record[ASTStmtReader::NumExprFields],
3748  /*HasFPFeatures*/ Record[ASTStmtReader::NumExprFields + 1]);
3749  break;
3750 
3751  case EXPR_CXX_DYNAMIC_CAST:
3752  S = CXXDynamicCastExpr::CreateEmpty(Context,
3753  /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3754  break;
3755 
3758  /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3759  break;
3760 
3761  case EXPR_CXX_CONST_CAST:
3762  S = CXXConstCastExpr::CreateEmpty(Context);
3763  break;
3764 
3766  S = CXXAddrspaceCastExpr::CreateEmpty(Context);
3767  break;
3768 
3771  Context,
3772  /*PathSize*/ Record[ASTStmtReader::NumExprFields],
3773  /*HasFPFeatures*/ Record[ASTStmtReader::NumExprFields + 1]);
3774  break;
3775 
3776  case EXPR_BUILTIN_BIT_CAST:
3777  assert(Record[ASTStmtReader::NumExprFields] == 0 && "Wrong PathSize!");
3778  S = new (Context) BuiltinBitCastExpr(Empty);
3779  break;
3780 
3783  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields],
3784  /*HasFPFeatures=*/Record[ASTStmtReader::NumExprFields + 1], Empty);
3785  break;
3786 
3788  S = new (Context) CXXStdInitializerListExpr(Empty);
3789  break;
3790 
3791  case EXPR_CXX_BOOL_LITERAL:
3792  S = new (Context) CXXBoolLiteralExpr(Empty);
3793  break;
3794 
3796  S = new (Context) CXXNullPtrLiteralExpr(Empty);
3797  break;
3798 
3799  case EXPR_CXX_TYPEID_EXPR:
3800  S = new (Context) CXXTypeidExpr(Empty, true);
3801  break;
3802 
3803  case EXPR_CXX_TYPEID_TYPE:
3804  S = new (Context) CXXTypeidExpr(Empty, false);
3805  break;
3806 
3807  case EXPR_CXX_UUIDOF_EXPR:
3808  S = new (Context) CXXUuidofExpr(Empty, true);
3809  break;
3810 
3812  S = new (Context) MSPropertyRefExpr(Empty);
3813  break;
3814 
3816  S = new (Context) MSPropertySubscriptExpr(Empty);
3817  break;
3818 
3819  case EXPR_CXX_UUIDOF_TYPE:
3820  S = new (Context) CXXUuidofExpr(Empty, false);
3821  break;
3822 
3823  case EXPR_CXX_THIS:
3824  S = new (Context) CXXThisExpr(Empty);
3825  break;
3826 
3827  case EXPR_CXX_THROW:
3828  S = new (Context) CXXThrowExpr(Empty);
3829  break;
3830 
3831  case EXPR_CXX_DEFAULT_ARG:
3832  S = new (Context) CXXDefaultArgExpr(Empty);
3833  break;
3834 
3835  case EXPR_CXX_DEFAULT_INIT:
3836  S = new (Context) CXXDefaultInitExpr(Empty);
3837  break;
3838 
3840  S = new (Context) CXXBindTemporaryExpr(Empty);
3841  break;
3842 
3844  S = new (Context) CXXScalarValueInitExpr(Empty);
3845  break;
3846 
3847  case EXPR_CXX_NEW:
3849  Context,
3850  /*IsArray=*/Record[ASTStmtReader::NumExprFields],
3851  /*HasInit=*/Record[ASTStmtReader::NumExprFields + 1],
3852  /*NumPlacementArgs=*/Record[ASTStmtReader::NumExprFields + 2],
3853  /*IsParenTypeId=*/Record[ASTStmtReader::NumExprFields + 3]);
3854  break;
3855 
3856  case EXPR_CXX_DELETE:
3857  S = new (Context) CXXDeleteExpr(Empty);
3858  break;
3859 
3861  S = new (Context) CXXPseudoDestructorExpr(Empty);
3862  break;
3863 
3865  S = ExprWithCleanups::Create(Context, Empty,
3867  break;
3868 
3871  Context,
3872  /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3873  /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 1],
3874  /*HasFirstQualifierFoundInScope=*/
3875  Record[ASTStmtReader::NumExprFields + 2]);
3876  break;
3877 
3880  /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3881  /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3882  ? Record[ASTStmtReader::NumExprFields + 1]
3883  : 0);
3884  break;
3885 
3888  /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
3889  break;
3890 
3893  Context,
3894  /*NumResults=*/Record[ASTStmtReader::NumExprFields],
3895  /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 1],
3896  /*NumTemplateArgs=*/
3897  Record[ASTStmtReader::NumExprFields + 1]
3898  ? Record[ASTStmtReader::NumExprFields + 2]
3899  : 0);
3900  break;
3901 
3904  Context,
3905  /*NumResults=*/Record[ASTStmtReader::NumExprFields],
3906  /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 1],
3907  /*NumTemplateArgs=*/
3908  Record[ASTStmtReader::NumExprFields + 1]
3909  ? Record[ASTStmtReader::NumExprFields + 2]
3910  : 0);
3911  break;
3912 
3913  case EXPR_TYPE_TRAIT:
3916  break;
3917 
3918  case EXPR_ARRAY_TYPE_TRAIT:
3919  S = new (Context) ArrayTypeTraitExpr(Empty);
3920  break;
3921 
3923  S = new (Context) ExpressionTraitExpr(Empty);
3924  break;
3925 
3926  case EXPR_CXX_NOEXCEPT:
3927  S = new (Context) CXXNoexceptExpr(Empty);
3928  break;
3929 
3930  case EXPR_PACK_EXPANSION:
3931  S = new (Context) PackExpansionExpr(Empty);
3932  break;
3933 
3934  case EXPR_SIZEOF_PACK:
3936  Context,
3937  /*NumPartialArgs=*/Record[ASTStmtReader::NumExprFields]);
3938  break;
3939 
3941  S = new (Context) SubstNonTypeTemplateParmExpr(Empty);
3942  break;
3943 
3945  S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
3946  break;
3947 
3951  break;
3952 
3954  S = new (Context) MaterializeTemporaryExpr(Empty);
3955  break;
3956 
3957  case EXPR_CXX_FOLD:
3958  S = new (Context) CXXFoldExpr(Empty);
3959  break;
3960 
3961  case EXPR_OPAQUE_VALUE:
3962  S = new (Context) OpaqueValueExpr(Empty);
3963  break;
3964 
3965  case EXPR_CUDA_KERNEL_CALL:
3967  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields],
3968  /*HasFPFeatures=*/Record[ASTStmtReader::NumExprFields + 1], Empty);
3969  break;
3970 
3971  case EXPR_ASTYPE:
3972  S = new (Context) AsTypeExpr(Empty);
3973  break;
3974 
3975  case EXPR_PSEUDO_OBJECT: {
3976  unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields];
3977  S = PseudoObjectExpr::Create(Context, Empty, numSemanticExprs);
3978  break;
3979  }
3980 
3981  case EXPR_ATOMIC:
3982  S = new (Context) AtomicExpr(Empty);
3983  break;
3984 
3985  case EXPR_LAMBDA: {
3986  unsigned NumCaptures = Record[ASTStmtReader::NumExprFields];
3987  S = LambdaExpr::CreateDeserialized(Context, NumCaptures);
3988  break;
3989  }
3990 
3991  case STMT_COROUTINE_BODY: {
3992  unsigned NumParams = Record[ASTStmtReader::NumStmtFields];
3993  S = CoroutineBodyStmt::Create(Context, Empty, NumParams);
3994  break;
3995  }
3996 
3997  case STMT_CORETURN:
3998  S = new (Context) CoreturnStmt(Empty);
3999  break;
4000 
4001  case EXPR_COAWAIT:
4002  S = new (Context) CoawaitExpr(Empty);
4003  break;
4004 
4005  case EXPR_COYIELD:
4006  S = new (Context) CoyieldExpr(Empty);
4007  break;
4008 
4010  S = new (Context) DependentCoawaitExpr(Empty);
4011  break;
4012 
4014  S = new (Context) ConceptSpecializationExpr(Empty);
4015  break;
4016  }
4017 
4018  case EXPR_REQUIRES:
4019  unsigned numLocalParameters = Record[ASTStmtReader::NumExprFields];
4020  unsigned numRequirement = Record[ASTStmtReader::NumExprFields + 1];
4021  S = RequiresExpr::Create(Context, Empty, numLocalParameters,
4022  numRequirement);
4023  break;
4024  }
4025 
4026  // We hit a STMT_STOP, so we're done with this expression.
4027  if (Finished)
4028  break;
4029 
4030  ++NumStatementsRead;
4031 
4032  if (S && !IsStmtReference) {
4033  Reader.Visit(S);
4034  StmtEntries[Cursor.GetCurrentBitNo()] = S;
4035  }
4036 
4037  assert(Record.getIdx() == Record.size() &&
4038  "Invalid deserialization of statement");
4039  StmtStack.push_back(S);
4040  }
4041 Done:
4042  assert(StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!");
4043  assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
4044  return StmtStack.pop_back_val();
4045 }
clang::OMPIteratorHelperData::Update
Expr * Update
Update expression for the originally specified iteration variable, calculated as VD = Begin + Counter...
Definition: ExprOpenMP.h:243
clang::StmtVisitor
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:183
clang::ArrayInitIndexExpr
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
Definition: Expr.h:5479
clang::OMPIteratorExpr::setLParenLoc
void setLParenLoc(SourceLocation L)
Definition: ExprOpenMP.h:367
clang::CompoundLiteralExpr::setLParenLoc
void setLParenLoc(SourceLocation L)
Definition: Expr.h:3441
clang::OMPTeamsDirective::CreateEmpty
static OMPTeamsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1055
clang::IndirectGotoStmt
IndirectGotoStmt - This represents an indirect goto.
Definition: Stmt.h:2680
clang::LabelStmt
LabelStmt - Represents a label, which has a substatement.
Definition: Stmt.h:1835
clang::serialization::EXPR_CHARACTER_LITERAL
@ EXPR_CHARACTER_LITERAL
A CharacterLiteral record.
Definition: ASTBitCodes.h:1623
clang::serialization::STMT_CXX_TRY
@ STMT_CXX_TRY
A CXXTryStmt record.
Definition: ASTBitCodes.h:1805
clang::ExpressionTraitExpr
An expression trait intrinsic.
Definition: ExprCXX.h:2847
clang::ObjCMessageExpr::SuperInstance
@ SuperInstance
The receiver is the instance of the superclass object.
Definition: ExprObjC.h:1097
clang::OMPForDirective
This represents '#pragma omp for' directive.
Definition: StmtOpenMP.h:1632
clang::CallExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: Expr.h:3121
clang::concepts::Requirement::RequirementKind
RequirementKind
Definition: ExprConcepts.h:149
clang::serialization::STMT_MS_DEPENDENT_EXISTS
@ STMT_MS_DEPENDENT_EXISTS
Definition: ASTBitCodes.h:1994
clang::CompoundStmt::CreateEmpty
static CompoundStmt * CreateEmpty(const ASTContext &C, unsigned NumStmts, bool HasFPFeatures)
Definition: Stmt.cpp:391
clang::OMPIteratorExpr
OpenMP 5.0 [2.1.6 Iterators] Iterators are identifiers that expand to multiple values in the clause o...
Definition: ExprOpenMP.h:272
clang::MatrixSubscriptExpr
MatrixSubscriptExpr - Matrix subscript expression for the MatrixType extension.
Definition: Expr.h:2732
clang::SubstNonTypeTemplateParmExpr
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:4269
clang::RecoveryExpr::children
child_range children()
Definition: Expr.h:6443
clang::serialization::STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE
@ STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE
Definition: ASTBitCodes.h:1948
clang::AtomicExpr
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...
Definition: Expr.h:6239
clang::OMPMasterTaskLoopSimdDirective
This represents '#pragma omp master taskloop simd' directive.
Definition: StmtOpenMP.h:3950
clang::CaseStmt
CaseStmt - Represent a case statement.
Definition: Stmt.h:1603
clang::OMPParallelDirective::CreateEmpty
static OMPParallelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:292
clang::OMPTaskyieldDirective
This represents '#pragma omp taskyield' directive.
Definition: StmtOpenMP.h:2526
clang::ArrayTypeTrait
ArrayTypeTrait
Names for the array type traits.
Definition: TypeTraits.h:42
clang::OMPExecutableDirective::setLocEnd
void setLocEnd(SourceLocation Loc)
Set ending location of directive.
Definition: StmtOpenMP.h:501
clang::serialization::EXPR_OBJC_PROPERTY_REF_EXPR
@ EXPR_OBJC_PROPERTY_REF_EXPR
An ObjCPropertyRefExpr record.
Definition: ASTBitCodes.h:1755
clang::ImaginaryLiteral
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....
Definition: Expr.h:1727
clang::serialization::EXPR_PSEUDO_OBJECT
@ EXPR_PSEUDO_OBJECT
A PseudoObjectExpr record.
Definition: ASTBitCodes.h:1725
clang::Expr::setValueKind
void setValueKind(ExprValueKind Cat)
setValueKind - Set the value kind produced by this expression.
Definition: Expr.h:447
clang::serialization::STMT_DECL
@ STMT_DECL
A DeclStmt record.
Definition: ASTBitCodes.h:1590
clang::ObjCArrayLiteral::CreateEmpty
static ObjCArrayLiteral * CreateEmpty(const ASTContext &C, unsigned NumElements)
Definition: ExprObjC.cpp:47
clang::OMPParallelMasterDirective::CreateEmpty
static OMPParallelMasterDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:679
clang::DesignatedInitUpdateExpr::setUpdater
void setUpdater(Expr *Updater)
Definition: Expr.h:5397
clang::ArrayTypeTraitExpr
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent.
Definition: ExprCXX.h:2777
clang::ASTRecordReader::getContext
ASTContext & getContext()
Retrieve the AST context that this AST reader supplements.
Definition: ASTRecordReader.h:58
clang::ObjCBoxedExpr
ObjCBoxedExpr - used for generalized expression boxing.
Definition: ExprObjC.h:128
clang::CallExpr::setPreArg
void setPreArg(unsigned I, Stmt *PreArg)
Definition: Expr.h:2898
clang::CaseStmt::CreateEmpty
static CaseStmt * CreateEmpty(const ASTContext &Ctx, bool CaseStmtIsGNURange)
Build an empty case statement.
Definition: Stmt.cpp:1228
clang::CXXBoolLiteralExpr
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition: ExprCXX.h:721
clang::CharacterLiteral::CharacterKind
CharacterKind
Definition: Expr.h:1595
clang::OMPTeamsGenericLoopDirective::CreateEmpty
static OMPTeamsGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:2390
clang::OverloadExpr::getTrailingASTTemplateKWAndArgsInfo
ASTTemplateKWAndArgsInfo * getTrailingASTTemplateKWAndArgsInfo()
Return the optional template keyword and arguments info.
Definition: ExprCXX.h:3994
clang::OffsetOfExpr::setComponent
void setComponent(unsigned Idx, OffsetOfNode ON)
Definition: Expr.h:2507
clang::serialization::EXPR_GENERIC_SELECTION
@ EXPR_GENERIC_SELECTION
A GenericSelectionExpr record.
Definition: ASTBitCodes.h:1722
clang::PredefinedExpr::CreateEmpty
static PredefinedExpr * CreateEmpty(const ASTContext &Ctx, bool HasFunctionName)
Create an empty PredefinedExpr.
Definition: Expr.cpp:692
clang::AsTypeExpr
AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2] This AST node provides support ...
Definition: Expr.h:6036
clang::OffsetOfExpr
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type,...
Definition: Expr.h:2453
Specifiers.h
clang::serialization::STMT_CAPTURED
@ STMT_CAPTURED
A CapturedStmt record.
Definition: ASTBitCodes.h:1593
clang::serialization::STMT_OMP_GENERIC_LOOP_DIRECTIVE
@ STMT_OMP_GENERIC_LOOP_DIRECTIVE
Definition: ASTBitCodes.h:1982
clang::serialization::STMT_OMP_TARGET_DATA_DIRECTIVE
@ STMT_OMP_TARGET_DATA_DIRECTIVE
Definition: ASTBitCodes.h:1944
clang::serialization::STMT_CASE
@ STMT_CASE
A CaseStmt record.
Definition: ASTBitCodes.h:1548
clang::CXXPseudoDestructorExpr
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Definition: ExprCXX.h:2541
clang::FloatingLiteral::setValue
void setValue(const ASTContext &C, const llvm::APFloat &Val)
Definition: Expr.h:1665
clang::ChooseExpr::setCond
void setCond(Expr *E)
Definition: Expr.h:4570
clang::OMPTargetExitDataDirective::CreateEmpty
static OMPTargetExitDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:1040
clang::CoawaitExpr::setIsImplicit
void setIsImplicit(bool value=true)
Definition: ExprCXX.h:4846
clang::SYCLUniqueStableNameExpr::CreateEmpty
static SYCLUniqueStableNameExpr * CreateEmpty(const ASTContext &Ctx)
Definition: Expr.cpp:634
clang::serialization::EXPR_INTEGER_LITERAL
@ EXPR_INTEGER_LITERAL
An IntegerLiteral record.
Definition: ASTBitCodes.h:1611
clang::serialization::EXPR_SHUFFLE_VECTOR
@ EXPR_SHUFFLE_VECTOR
A ShuffleVectorExpr record.
Definition: ASTBitCodes.h:1713
clang::OMPTileDirective
This represents the '#pragma omp tile' loop transformation directive.
Definition: StmtOpenMP.h:5492
clang::SwitchStmt
SwitchStmt - This represents a 'switch' stmt.
Definition: Stmt.h:2186
clang::serialization::STMT_OBJC_AT_THROW
@ STMT_OBJC_AT_THROW
An ObjCAtThrowStmt record.
Definition: ASTBitCodes.h:1788
clang::SourceLocExpr::IdentKind
IdentKind
Definition: Expr.h:4692
clang::ObjCDictionaryLiteral::getNumElements
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c dictionary literal.
Definition: ExprObjC.h:360
clang::OMPMaskedDirective
This represents '#pragma omp masked' directive.
Definition: StmtOpenMP.h:5819
Error
llvm::Error Error
Definition: ByteCodeEmitter.cpp:20
clang::serialization::EXPR_CXX_UNRESOLVED_LOOKUP
@ EXPR_CXX_UNRESOLVED_LOOKUP
Definition: ASTBitCodes.h:1878
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:210
clang::serialization::EXPR_OMP_ARRAY_SECTION
@ EXPR_OMP_ARRAY_SECTION
Definition: ASTBitCodes.h:1987
DeclAccessPair.h
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::Stmt::CXXNewExprBits
CXXNewExprBitfields CXXNewExprBits
Definition: Stmt.h:1061
clang::Stmt::PseudoObjectExprBits
PseudoObjectExprBitfields PseudoObjectExprBits
Definition: Stmt.h:1045
clang::WhileStmt
WhileStmt - This represents a 'while' stmt.
Definition: Stmt.h:2377
clang::ObjCIvarRefExpr::setOpLoc
void setOpLoc(SourceLocation L)
Definition: ExprObjC.h:598
clang::OMPArrayShapingExpr::CreateEmpty
static OMPArrayShapingExpr * CreateEmpty(const ASTContext &Context, unsigned NumDims)
Definition: Expr.cpp:4976
clang::NullStmt
NullStmt - This is the null statement ";": C99 6.8.3p3.
Definition: Stmt.h:1375
clang::serialization::STMT_NULL
@ STMT_NULL
A NullStmt record.
Definition: ASTBitCodes.h:1542
clang::serialization::STMT_OMP_CANONICAL_LOOP
@ STMT_OMP_CANONICAL_LOOP
Definition: ASTBitCodes.h:1916
clang::ObjCArrayLiteral::getNumElements
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c array literal.
Definition: ExprObjC.h:229
clang::StringLiteral::CreateEmpty
static StringLiteral * CreateEmpty(const ASTContext &Ctx, unsigned NumConcatenated, unsigned Length, unsigned CharByteWidth)
Construct an empty string literal.
Definition: Expr.cpp:1195
clang::serialization::EXPR_CXX_UNRESOLVED_MEMBER
@ EXPR_CXX_UNRESOLVED_MEMBER
Definition: ASTBitCodes.h:1877
clang::serialization::STMT_MSASM
@ STMT_MSASM
A MS-style AsmStmt record.
Definition: ASTBitCodes.h:1599
clang::OMPCancelDirective::CreateEmpty
static OMPCancelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:828
clang::serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE
@ STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1977
clang::CXXReinterpretCastExpr
A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]).
Definition: ExprCXX.h:521
clang::FunctionParmPackExpr::CreateEmpty
static FunctionParmPackExpr * CreateEmpty(const ASTContext &Context, unsigned NumParams)
Definition: ExprCXX.cpp:1634
clang::TypeTraitExpr::getNumArgs
unsigned getNumArgs() const
Determine the number of arguments to this type trait.
Definition: ExprCXX.h:2738
clang::CXXConstructExpr::getNumArgs
unsigned getNumArgs() const
Return the number of arguments to the constructor call.
Definition: ExprCXX.h:1615
clang::serialization::EXPR_CONVERT_VECTOR
@ EXPR_CONVERT_VECTOR
A ConvertVectorExpr record.
Definition: ASTBitCodes.h:1716
clang::CXXBoolLiteralExpr::setValue
void setValue(bool V)
Definition: ExprCXX.h:739
clang::TemplateArgument::pack_begin
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
Definition: TemplateBase.h:351
DependenceFlags.h
clang::OMPParallelMasterTaskLoopDirective
This represents '#pragma omp parallel master taskloop' directive.
Definition: StmtOpenMP.h:4081
clang::serialization::EXPR_PACK_EXPANSION
@ EXPR_PACK_EXPANSION
Definition: ASTBitCodes.h:1888
clang::OMPTargetParallelGenericLoopDirective
This represents '#pragma omp target parallel loop' directive.
Definition: StmtOpenMP.h:6167
clang::serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF
@ EXPR_CXX_DEPENDENT_SCOPE_DECL_REF
Definition: ASTBitCodes.h:1875
clang::OMPDistributeParallelForSimdDirective::CreateEmpty
static OMPDistributeParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1684
clang::ObjCIvarRefExpr::setDecl
void setDecl(ObjCIvarDecl *d)
Definition: ExprObjC.h:578
clang::serialization::EXPR_CSTYLE_CAST
@ EXPR_CSTYLE_CAST
A CStyleCastExpr record.
Definition: ASTBitCodes.h:1665
clang::OMPIteratorHelperData
Helper expressions and declaration for OMPIteratorExpr class for each iteration space.
Definition: ExprOpenMP.h:235
clang::serialization::EXPR_CONDITIONAL_OPERATOR
@ EXPR_CONDITIONAL_OPERATOR
A ConditionOperator record.
Definition: ASTBitCodes.h:1659
clang::OMPErrorDirective::CreateEmpty
static OMPErrorDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:756
clang::DesignatedInitExpr
Represents a C99 designated initializer expression.
Definition: Expr.h:5034
clang::OMPTargetTeamsDistributeDirective
This represents '#pragma omp target teams distribute' combined directive.
Definition: StmtOpenMP.h:5199
clang::concepts::TypeRequirement::SS_SubstitutionFailure
@ SS_SubstitutionFailure
Definition: ExprConcepts.h:203
clang::SubstNonTypeTemplateParmPackExpr
Represents a reference to a non-type template parameter pack that has been substituted with a non-tem...
Definition: ExprCXX.h:4354
clang::UnresolvedMemberExpr::CreateEmpty
static UnresolvedMemberExpr * CreateEmpty(const ASTContext &Context, unsigned NumResults, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
Definition: ExprCXX.cpp:1519
clang::CXXConstCastExpr::CreateEmpty
static CXXConstCastExpr * CreateEmpty(const ASTContext &Context)
Definition: ExprCXX.cpp:825
clang::OMPDepobjDirective::CreateEmpty
static OMPDepobjDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:858
clang::OMPTargetTeamsDistributeSimdDirective
This represents '#pragma omp target teams distribute simd' combined directive.
Definition: StmtOpenMP.h:5434
clang::CXXNewExpr::CreateEmpty
static CXXNewExpr * CreateEmpty(const ASTContext &Ctx, bool IsArray, bool HasInit, unsigned NumPlacementArgs, bool IsParenTypeId)
Create an empty c++ new expression.
Definition: ExprCXX.cpp:266
llvm::SmallVector
Definition: LLVM.h:38
clang::OMPCanonicalLoop
Representation of an OpenMP canonical loop.
Definition: StmtOpenMP.h:142
clang::serialization::STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE
@ STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1956
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::OMPTileDirective::CreateEmpty
static OMPTileDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned NumLoops)
Build an empty '#pragma omp tile' AST node for deserialization.
Definition: StmtOpenMP.cpp:420
clang::MSPropertyRefExpr
A member reference to an MSPropertyDecl.
Definition: ExprCXX.h:930
clang::DeclGroup::Create
static DeclGroup * Create(ASTContext &C, Decl **Decls, unsigned NumDecls)
Definition: DeclGroup.cpp:20
clang::Stmt::GenericSelectionExprBits
GenericSelectionExprBitfields GenericSelectionExprBits
Definition: Stmt.h:1044
clang::AttributedStmt::CreateEmpty
static AttributedStmt * CreateEmpty(const ASTContext &C, unsigned NumAttrs)
Definition: Stmt.cpp:432
clang::DesignatedInitExpr::setSubExpr
void setSubExpr(unsigned Idx, Expr *E)
Definition: Expr.h:5294
clang::OMPTargetParallelDirective::CreateEmpty
static OMPTargetParallelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:951
clang::ASTRecordReader
An object for streaming information from a record.
Definition: ASTRecordReader.h:31
clang::NamedDecl
This represents a decl that may have a name.
Definition: Decl.h:247
clang::serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE
@ STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1978
clang::Stmt::CXXOperatorCallExprBits
CXXOperatorCallExprBitfields CXXOperatorCallExprBits
Definition: Stmt.h:1052
clang::ObjCStringLiteral::setString
void setString(StringLiteral *S)
Definition: ExprObjC.h:67
clang::ParenListExpr
Definition: Expr.h:5542
clang::SourceRange::getBegin
SourceLocation getBegin() const
Definition: SourceLocation.h:219
clang::StmtExpr::setSubStmt
void setSubStmt(CompoundStmt *S)
Definition: Expr.h:4373
clang::serialization::EXPR_OBJC_BOOL_LITERAL
@ EXPR_OBJC_BOOL_LITERAL
An ObjCBoolLiteralExpr record.
Definition: ASTBitCodes.h:1794
clang::OMPMasterDirective
This represents '#pragma omp master' directive.
Definition: StmtOpenMP.h:1975
clang::ObjCMessageExpr::setClassReceiver
void setClassReceiver(TypeSourceInfo *TSInfo)
Definition: ExprObjC.h:1284
clang::serialization::EXPR_STRING_LITERAL
@ EXPR_STRING_LITERAL
A StringLiteral record.
Definition: ASTBitCodes.h:1620
clang::OMPMasterTaskLoopDirective::CreateEmpty
static OMPMasterTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1186
clang::OffsetOfExpr::CreateEmpty
static OffsetOfExpr * CreateEmpty(const ASTContext &C, unsigned NumComps, unsigned NumExprs)
Definition: Expr.cpp:1651
clang::CXXNewExpr::getNumPlacementArgs
unsigned getNumPlacementArgs() const
Definition: ExprCXX.h:2299
clang::ExprWithCleanups::getNumObjects
unsigned getNumObjects() const
Definition: ExprCXX.h:3399
clang::ArraySubscriptExpr::setLHS
void setLHS(Expr *E)
Definition: Expr.h:2685
clang::CharacterLiteral::setLocation
void setLocation(SourceLocation Location)
Definition: Expr.h:1629
clang::NoInitExpr
Represents a place-holder for an object not to be initialized by anything.
Definition: Expr.h:5335
clang::InitListExpr::reserveInits
void reserveInits(const ASTContext &C, unsigned NumInits)
Reserve space for some number of initializers.
Definition: Expr.cpp:2363
clang::DependentScopeDeclRefExpr::CreateEmpty
static DependentScopeDeclRefExpr * CreateEmpty(const ASTContext &Context, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
Definition: ExprCXX.cpp:493
clang::OffsetOfNode::Array
@ Array
An index into an array.
Definition: Expr.h:2354
clang::OMPTaskwaitDirective
This represents '#pragma omp taskwait' directive.
Definition: StmtOpenMP.h:2618
ExpressionTraits.h
clang::UnresolvedMemberExpr
Represents a C++ member access expression for which lookup produced a set of overloaded functions.
Definition: ExprCXX.h:3834
clang::serialization::STMT_FOR
@ STMT_FOR
A ForStmt record.
Definition: ASTBitCodes.h:1572
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:737
clang::serialization::STMT_OMP_TEAMS_GENERIC_LOOP_DIRECTIVE
@ STMT_OMP_TEAMS_GENERIC_LOOP_DIRECTIVE
Definition: ASTBitCodes.h:1983
clang::OMPArraySectionExpr::setColonLocFirst
void setColonLocFirst(SourceLocation L)
Definition: ExprOpenMP.h:119
clang::FloatingLiteral::setRawSemantics
void setRawSemantics(llvm::APFloatBase::Semantics Sem)
Set the raw enumeration value representing the floating-point semantics of this literal (32-bit IEEE,...
Definition: Expr.h:1679
clang::ObjCBridgedCastExpr
An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers,...
Definition: ExprObjC.h:1625
clang::serialization::EXPR_OBJC_ARRAY_LITERAL
@ EXPR_OBJC_ARRAY_LITERAL
Definition: ASTBitCodes.h:1739
clang::Stmt::TypeTraitExprBits
TypeTraitExprBitfields TypeTraitExprBits
Definition: Stmt.h:1063
AttributeLangSupport::C
@ C
Definition: SemaDeclAttr.cpp:56
clang::CXXNewExpr::isArray
bool isArray() const
Definition: ExprCXX.h:2269
clang::serialization::STMT_OBJC_AT_SYNCHRONIZED
@ STMT_OBJC_AT_SYNCHRONIZED
An ObjCAtSynchronizedStmt record.
Definition: ASTBitCodes.h:1785
clang::OMPSectionDirective
This represents '#pragma omp section' directive.
Definition: StmtOpenMP.h:1862
Cursor
Cursor
Definition: SerializedDiagnosticReader.cpp:109
clang::serialization::EXPR_CXX_PROPERTY_REF_EXPR
@ EXPR_CXX_PROPERTY_REF_EXPR
Definition: ASTBitCodes.h:1905
clang::serialization::EXPR_IMPLICIT_VALUE_INIT
@ EXPR_IMPLICIT_VALUE_INIT
An ImplicitValueInitExpr record.
Definition: ASTBitCodes.h:1692
clang::serialization::EXPR_CXX_FUNCTIONAL_CAST
@ EXPR_CXX_FUNCTIONAL_CAST
A CXXFunctionalCastExpr record.
Definition: ASTBitCodes.h:1844
clang::TypeTraitExpr
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
Definition: ExprCXX.h:2689
clang::serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK
@ EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK
Definition: ASTBitCodes.h:1891
clang::CXXTypeidExpr
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:846
clang::CXXUnresolvedConstructExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: ExprCXX.h:3502
clang::UnresolvedSetIterator
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
clang::concepts::Requirement::SubstitutionDiagnostic
Definition: ExprConcepts.h:157
clang::serialization::EXPR_OBJC_MESSAGE_EXPR
@ EXPR_OBJC_MESSAGE_EXPR
An ObjCMessageExpr record.
Definition: ASTBitCodes.h:1764
clang::ObjCMessageExpr::setSuper
void setSuper(SourceLocation Loc, QualType T, bool IsInstanceSuper)
Definition: ExprObjC.h:1333
clang::RequiresExpr
C++2a [expr.prim.req]: A requires-expression provides a concise way to express requirements on templa...
Definition: ExprConcepts.h:471
clang::CXXFunctionalCastExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: ExprCXX.h:1776
clang::serialization::STMT_COMPOUND
@ STMT_COMPOUND
A CompoundStmt record.
Definition: ASTBitCodes.h:1545
clang::OverloadExpr::hasTemplateKWAndArgsInfo
bool hasTemplateKWAndArgsInfo() const
Definition: ExprCXX.h:2948
clang::ASTStmtReader::NumExprFields
static const unsigned NumExprFields
The number of record fields required for the Expr class itself.
Definition: ASTReaderStmt.cpp:110
clang::OffsetOfExpr::setRParenLoc
void setRParenLoc(SourceLocation R)
Definition: Expr.h:2493
clang::ParmVarDecl
Represents a parameter to a function.
Definition: Decl.h:1712
clang::Stmt::ConstantExprBits
ConstantExprBitfields ConstantExprBits
Definition: Stmt.h:1029
DeclCXX.h
clang::ASTStmtReader::NumStmtFields
static const unsigned NumStmtFields
The number of record fields required for the Stmt class itself.
Definition: ASTReaderStmt.cpp:106
int
__device__ int
Definition: __clang_hip_libdevice_declares.h:63
clang::OMPTeamsDistributeSimdDirective
This represents '#pragma omp teams distribute simd' combined directive.
Definition: StmtOpenMP.h:4916
AttrIterator.h
clang::Stmt::StringLiteralBits
StringLiteralBitfields StringLiteralBits
Definition: Stmt.h:1033
clang::serialization::STMT_CONTINUE
@ STMT_CONTINUE
A ContinueStmt record.
Definition: ASTBitCodes.h:1581
clang::VAArgExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: Expr.h:4669
clang::OMPCancellationPointDirective::CreateEmpty
static OMPCancellationPointDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:813
clang::CXXNewExpr
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
Definition: ExprCXX.h:2146
clang::IfStmt
IfStmt - This represents an if/then/else.
Definition: Stmt.h:1940
clang::ExprObjectKind
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
Definition: Specifiers.h:137
clang::ObjCAtTryStmt
Represents Objective-C's @try ... @catch ... @finally statement.
Definition: StmtObjC.h:165
clang::RecoveryExpr
Frontend produces RecoveryExprs on semantic errors that prevent creating other well-formed expression...
Definition: Expr.h:6426
clang::serialization::EXPR_STMT
@ EXPR_STMT
A StmtExpr record.
Definition: ASTBitCodes.h:1701
clang::OMPIteratorExpr::CreateEmpty
static OMPIteratorExpr * CreateEmpty(const ASTContext &Context, unsigned NumIterators)
Definition: Expr.cpp:5107
clang::serialization::EXPR_CXX_DELETE
@ EXPR_CXX_DELETE
Definition: ASTBitCodes.h:1869
clang::CapturedRegionKind
CapturedRegionKind
The different kinds of captured statement.
Definition: CapturedStmt.h:16
clang::GotoStmt
GotoStmt - This represents a direct goto.
Definition: Stmt.h:2641
clang::InitListExpr
Describes an C or C++ initializer list.
Definition: Expr.h:4796
clang::APValue::needsCleanup
bool needsCleanup() const
Returns whether the object performed allocations.
Definition: APValue.cpp:429
clang::serialization::EXPR_CXX_TYPEID_TYPE
@ EXPR_CXX_TYPEID_TYPE
Definition: ASTBitCodes.h:1860
clang::serialization::EXPR_CXX_PSEUDO_DESTRUCTOR
@ EXPR_CXX_PSEUDO_DESTRUCTOR
Definition: ASTBitCodes.h:1870
clang::Stmt::CXXScalarValueInitExprBits
CXXScalarValueInitExprBitfields CXXScalarValueInitExprBits
Definition: Stmt.h:1060
llvm::Optional
Definition: LLVM.h:40
clang::OMPTaskgroupDirective::CreateEmpty
static OMPTaskgroupDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:797
clang::OMPLoopTransformationDirective
The base class for all loop transformation directives.
Definition: StmtOpenMP.h:959
clang::serialization::STMT_OMP_DISTRIBUTE_DIRECTIVE
@ STMT_OMP_DISTRIBUTE_DIRECTIVE
Definition: ASTBitCodes.h:1963
clang::CompoundAssignOperator::setComputationLHSType
void setComputationLHSType(QualType T)
Definition: Expr.h:4094
clang::serialization::STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE
@ STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1929
ASTRecordReader.h
clang::ObjCBoolLiteralExpr::setValue
void setValue(bool V)
Definition: ExprObjC.h:102
clang::OMPDistributeDirective::CreateEmpty
static OMPDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1551
clang::serialization::STMT_OMP_ORDERED_DIRECTIVE
@ STMT_OMP_ORDERED_DIRECTIVE
Definition: ASTBitCodes.h:1941
clang::serialization::EXPR_CXX_SCALAR_VALUE_INIT
@ EXPR_CXX_SCALAR_VALUE_INIT
Definition: ASTBitCodes.h:1867
clang::UnaryOperator
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Definition: Expr.h:2172
clang::serialization::EXPR_ARRAY_INIT_INDEX
@ EXPR_ARRAY_INIT_INDEX
An ArrayInitIndexExpr record.
Definition: ASTBitCodes.h:1689
clang::serialization::STMT_OMP_MASKED_DIRECTIVE
@ STMT_OMP_MASKED_DIRECTIVE
Definition: ASTBitCodes.h:1981
clang::OffsetOfExpr::getNumExpressions
unsigned getNumExpressions() const
Definition: Expr.h:2531
clang::UnaryOperator::setOperatorLoc
void setOperatorLoc(SourceLocation L)
Definition: Expr.h:2224
clang::CXXMemberCallExpr::CreateEmpty
static CXXMemberCallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty)
Definition: ExprCXX.cpp:638
clang::serialization::STMT_OMP_META_DIRECTIVE
@ STMT_OMP_META_DIRECTIVE
Definition: ASTBitCodes.h:1915
clang::ImplicitCastExpr::CreateEmpty
static ImplicitCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize, bool HasFPFeatures)
Definition: Expr.cpp:2084
clang::serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE
@ STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE
Definition: ASTBitCodes.h:1975
clang::serialization::EXPR_COAWAIT
@ EXPR_COAWAIT
Definition: ASTBitCodes.h:1998
clang::CoreturnStmt
Represents a 'co_return' statement in the C++ Coroutines TS.
Definition: StmtCXX.h:458
clang::Stmt::SourceLocExprBits
SourceLocExprBitfields SourceLocExprBits
Definition: Stmt.h:1046
llvm::Expected
Definition: LLVM.h:41
clang::OMPSingleDirective::CreateEmpty
static OMPSingleDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:542
clang::OMPIteratorExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: ExprOpenMP.h:370
ExprOpenMP.h
clang::CXXStaticCastExpr
A C++ static_cast expression (C++ [expr.static.cast]).
Definition: ExprCXX.h:431
clang::ObjCForCollectionStmt
Represents Objective-C's collection statement.
Definition: StmtObjC.h:23
clang::ObjCDictionaryLiteral_KeyValuePair
Internal struct for storing Key/value pair.
Definition: ExprObjC.h:286
clang::StmtExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: Expr.h:4381
clang::ObjCProtocolExpr::setAtLoc
void setAtLoc(SourceLocation L)
Definition: ExprObjC.h:527
clang::ArrayInitLoopExpr
Represents a loop initializing the elements of an array.
Definition: Expr.h:5426
clang::OMPSectionDirective::CreateEmpty
static OMPSectionDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:526
clang::serialization::STMT_OMP_SIMD_DIRECTIVE
@ STMT_OMP_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1918
clang::Stmt::SubstNonTypeTemplateParmExprBits
SubstNonTypeTemplateParmExprBitfields SubstNonTypeTemplateParmExprBits
Definition: Stmt.h:1073
clang::serialization::EXPR_CXX_NOEXCEPT
@ EXPR_CXX_NOEXCEPT
Definition: ASTBitCodes.h:1881
clang::CompoundLiteralExpr::setInitializer
void setInitializer(Expr *E)
Definition: Expr.h:3435
clang::OMPParallelMaskedTaskLoopSimdDirective::CreateEmpty
static OMPParallelMaskedTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1505
clang::serialization::EXPR_CXX_DYNAMIC_CAST
@ EXPR_CXX_DYNAMIC_CAST
A CXXDynamicCastExpr record.
Definition: ASTBitCodes.h:1832
clang::ObjCMessageExpr::SuperClass
@ SuperClass
The receiver is a superclass.
Definition: ExprObjC.h:1094
clang::CastExpr::setCastKind
void setCastKind(CastKind K)
Definition: Expr.h:3525
clang::OMPTargetParallelGenericLoopDirective::CreateEmpty
static OMPTargetParallelGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:2523
clang::serialization::STMT_OMP_TARGET_SIMD_DIRECTIVE
@ STMT_OMP_TARGET_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1969
clang::CastExpr::getTrailingFPFeatures
FPOptionsOverride * getTrailingFPFeatures()
Return a pointer to the trailing FPOptions.
Definition: Expr.cpp:2042
clang::CXXUnresolvedConstructExpr::getNumArgs
unsigned getNumArgs() const
Retrieve the number of arguments.
Definition: ExprCXX.h:3510
End
SourceLocation End
Definition: USRLocFinder.cpp:167
clang::serialization::EXPR_CXX_STD_INITIALIZER_LIST
@ EXPR_CXX_STD_INITIALIZER_LIST
A CXXStdInitializerListExpr record.
Definition: ASTBitCodes.h:1853
clang::serialization::EXPR_CXX_BOOL_LITERAL
@ EXPR_CXX_BOOL_LITERAL
A CXXBoolLiteralExpr record.
Definition: ASTBitCodes.h:1856
clang::ExprDependenceScope::ExprDependence
ExprDependence
Definition: DependenceFlags.h:17
clang::ConceptSpecializationExpr::Satisfaction
ASTConstraintSatisfaction * Satisfaction
Information about the satisfaction of the named concept with the given arguments.
Definition: ExprConcepts.h:55
clang::CallExpr::setADLCallKind
void setADLCallKind(ADLCallKind V=UsesADL)
Definition: Expr.h:2967
clang::DeclRefExpr::CreateEmpty
static DeclRefExpr * CreateEmpty(const ASTContext &Context, bool HasQualifier, bool HasFoundDecl, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
Construct an empty declaration reference expression.
Definition: Expr.cpp:576
clang::CoroutineBodyStmt::Create
static CoroutineBodyStmt * Create(const ASTContext &C, CtorArgs const &Args)
Definition: StmtCXX.cpp:86
clang::UnaryOperator::setCanOverflow
void setCanOverflow(bool C)
Definition: Expr.h:2233
clang::RequiresExpr::Create
static RequiresExpr * Create(ASTContext &C, SourceLocation RequiresKWLoc, RequiresExprBodyDecl *Body, ArrayRef< ParmVarDecl * > LocalParameters, ArrayRef< concepts::Requirement * > Requirements, SourceLocation RBraceLoc)
Definition: ExprConcepts.cpp:165
clang::ObjCBoolLiteralExpr::setLocation
void setLocation(SourceLocation L)
Definition: ExprObjC.h:108
clang::Stmt::ExprWithCleanupsBits
ExprWithCleanupsBitfields ExprWithCleanupsBits
Definition: Stmt.h:1066
clang::Stmt::EmptyShell
A placeholder type used to construct an empty shell of a type, that will be filled in later (e....
Definition: Stmt.h:1109
clang::OMPTargetTeamsDistributeParallelForDirective
This represents '#pragma omp target teams distribute parallel for' combined directive.
Definition: StmtOpenMP.h:5265
clang::FixedPointLiteral::Create
static FixedPointLiteral * Create(const ASTContext &C, EmptyShell Empty)
Returns an empty fixed-point literal.
Definition: Expr.cpp:1012
clang::ParenExpr::setLParen
void setLParen(SourceLocation Loc)
Definition: Expr.h:2145
clang::OpaqueValueExpr
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Definition: Expr.h:1144
clang::OMPArraySectionExpr::setLowerBound
void setLowerBound(Expr *E)
Set lower bound of the array section.
Definition: ExprOpenMP.h:99
clang::CXXUnresolvedConstructExpr::setArg
void setArg(unsigned I, Expr *E)
Definition: ExprCXX.h:3538
clang::SEHTryStmt
Definition: Stmt.h:3444
clang::serialization::STMT_OMP_MASKED_TASKLOOP_DIRECTIVE
@ STMT_OMP_MASKED_TASKLOOP_DIRECTIVE
Definition: ASTBitCodes.h:1959
clang::CUDAKernelCallExpr::CreateEmpty
static CUDAKernelCallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty)
Definition: ExprCXX.cpp:1750
clang::CXXFoldExpr
Represents a folding of a pack over an operator.
Definition: ExprCXX.h:4625
clang::serialization::STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE
@ STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE
Definition: ASTBitCodes.h:1946
clang::ObjCSubscriptRefExpr
ObjCSubscriptRefExpr - used for array and dictionary subscripting.
Definition: ExprObjC.h:841
clang::ObjCBoolLiteralExpr
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
Definition: ExprObjC.h:88
clang::ConstantExpr::RSK_Int64
@ RSK_Int64
Definition: Expr.h:1053
clang::serialization::EXPR_CALL
@ EXPR_CALL
A CallExpr record.
Definition: ASTBitCodes.h:1647
clang::OMPTaskgroupDirective
This represents '#pragma omp taskgroup' directive.
Definition: StmtOpenMP.h:2669
clang::serialization::EXPR_OBJC_DICTIONARY_LITERAL
@ EXPR_OBJC_DICTIONARY_LITERAL
Definition: ASTBitCodes.h:1740
Decl.h
clang::ObjCIndirectCopyRestoreExpr
ObjCIndirectCopyRestoreExpr - Represents the passing of a function argument by indirect copy-restore ...
Definition: ExprObjC.h:1566
clang::OMPIteratorHelperData::CounterVD
VarDecl * CounterVD
Internal normalized counter.
Definition: ExprOpenMP.h:237
clang::serialization::STMT_OBJC_AUTORELEASE_POOL
@ STMT_OBJC_AUTORELEASE_POOL
An ObjCAutoreleasePoolStmt record.
Definition: ASTBitCodes.h:1791
clang::ConditionalOperator
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:4150
clang::CXXThrowExpr
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:1188
clang::ObjCArrayLiteral
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp,...
Definition: ExprObjC.h:190
DeclObjC.h
clang::serialization::STMT_OMP_TASKLOOP_DIRECTIVE
@ STMT_OMP_TASKLOOP_DIRECTIVE
Definition: ASTBitCodes.h:1953
clang::serialization::EXPR_DESIGNATED_INIT
@ EXPR_DESIGNATED_INIT
A DesignatedInitExpr record.
Definition: ASTBitCodes.h:1677
clang::serialization::EXPR_OBJC_PROTOCOL_EXPR
@ EXPR_OBJC_PROTOCOL_EXPR
An ObjCProtocolExpr record.
Definition: ASTBitCodes.h:1749
clang::serialization::EXPR_ADDR_LABEL
@ EXPR_ADDR_LABEL
An AddrLabelExpr record.
Definition: ASTBitCodes.h:1698
clang::ObjCPropertyRefExpr
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
Definition: ExprObjC.h:614
clang::ConstraintSatisfaction::Details
llvm::SmallVector< std::pair< const Expr *, Detail >, 4 > Details
Pairs of unsatisfied atomic constraint expressions along with the substituted constraint expr,...
Definition: ASTConcept.h:53
clang::BinaryOperator::setStoredFPFeatures
void setStoredFPFeatures(FPOptionsOverride F)
Set FPFeatures in trailing storage, used only by Serialization.
Definition: Expr.h:4003
clang::ASTStmtReader::VisitStmt
void VisitStmt(Stmt *S)
Definition: ASTReaderStmt.cpp:141
clang::CXXTemporaryObjectExpr
Represents a C++ functional cast expression that builds a temporary object.
Definition: ExprCXX.h:1804
clang::FunctionParmPackExpr
Represents a reference to a function parameter pack or init-capture pack that has been substituted bu...
Definition: ExprCXX.h:4431
clang::serialization::EXPR_OBJC_BOXED_EXPRESSION
@ EXPR_OBJC_BOXED_EXPRESSION
Definition: ASTBitCodes.h:1738
clang::OMPTaskLoopDirective::CreateEmpty
static OMPTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1097
clang::FixedPointLiteral
Definition: Expr.h:1546
clang::OMPTargetExitDataDirective
This represents '#pragma omp target exit data' directive.
Definition: StmtOpenMP.h:3259
clang::FloatingLiteral::getSemantics
const llvm::fltSemantics & getSemantics() const
Return the APFloat semantics this literal uses.
Definition: Expr.h:1684
clang::OMPExecutableDirective::Data
OMPChildren * Data
Data, associated with the directive.
Definition: StmtOpenMP.h:286
clang::ConstantExpr::RSK_APValue
@ RSK_APValue
Definition: Expr.h:1053
clang::OMPForSimdDirective
This represents '#pragma omp for simd' directive.
Definition: StmtOpenMP.h:1722
clang::ArraySubscriptExpr::setRBracketLoc
void setRBracketLoc(SourceLocation L)
Definition: Expr.h:2705
clang::ObjCMessageExpr::setArg
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
Definition: ExprObjC.h:1395
clang::AttributedStmt
Represents an attribute applied to a statement.
Definition: Stmt.h:1882
clang::OMPParallelGenericLoopDirective
This represents '#pragma omp parallel loop' directive.
Definition: StmtOpenMP.h:6102
clang::OMPErrorDirective
This represents '#pragma omp error' directive.
Definition: StmtOpenMP.h:6229
clang::CXXDependentScopeMemberExpr::CreateEmpty
static CXXDependentScopeMemberExpr * CreateEmpty(const ASTContext &Ctx, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs, bool HasFirstQualifierFoundInScope)
Definition: ExprCXX.cpp:1429
clang::UnaryOperator::hasStoredFPFeatures
bool hasStoredFPFeatures() const
Is FPFeatures in Trailing Storage?
Definition: Expr.h:2315
TemplateBase.h
clang::IntegerLiteral
Definition: Expr.h:1503
clang::PseudoObjectExpr::Create
static PseudoObjectExpr * Create(const ASTContext &Context, Expr *syntactic, ArrayRef< Expr * > semantic, unsigned resultIndex)
Definition: Expr.cpp:4720
clang::serialization::STMT_OMP_UNROLL_DIRECTIVE
@ STMT_OMP_UNROLL_DIRECTIVE
Definition: ASTBitCodes.h:1920
clang::ObjCAtCatchStmt
Represents Objective-C's @catch statement.
Definition: StmtObjC.h:77
clang::UnaryExprOrTypeTraitExpr
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
Definition: Expr.h:2558
clang::FloatingLiteral
Definition: Expr.h:1648
clang::serialization::EXPR_CXX_CONSTRUCT
@ EXPR_CXX_CONSTRUCT
A CXXConstructExpr record.
Definition: ASTBitCodes.h:1820
clang::OMPTargetTeamsDistributeParallelForDirective::CreateEmpty
static OMPTargetTeamsDistributeParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:2143
clang::TemplateArgument::getKind
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:244
clang::AddrLabelExpr::setAmpAmpLoc
void setAmpAmpLoc(SourceLocation L)
Definition: Expr.h:4325
clang::ObjCIvarRefExpr::setIsArrow
void setIsArrow(bool A)
Definition: ExprObjC.h:586
clang::ASTRecordReader::readTypeSourceInfo
TypeSourceInfo * readTypeSourceInfo()
Reads a declarator info from the given record, advancing Idx.
Definition: ASTReader.cpp:6880
clang::MemberExprNameQualifier
Extra data stored in some MemberExpr objects.
Definition: Expr.h:3157
clang::CompoundStmt
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:1410
clang::ConvertVectorExpr
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
Definition: Expr.h:4470
clang::ObjCSelectorExpr
ObjCSelectorExpr used for @selector in Objective-C.
Definition: ExprObjC.h:454
DeclTemplate.h
clang::serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER
@ EXPR_CXX_DEPENDENT_SCOPE_MEMBER
Definition: ASTBitCodes.h:1874
clang::MSPropertySubscriptExpr
MS property subscript expression.
Definition: ExprCXX.h:1001
clang::serialization::ModuleFile::DeclsCursor
llvm::BitstreamCursor DeclsCursor
DeclsCursor - This is a cursor to the start of the DECLTYPES_BLOCK block.
Definition: ModuleFile.h:427
clang::CXXAddrspaceCastExpr
A C++ addrspace_cast expression (currently only enabled for OpenCL).
Definition: ExprCXX.h:600
clang::serialization::STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE
@ STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1958
clang::OMPParallelMasterDirective
This represents '#pragma omp parallel master' directive.
Definition: StmtOpenMP.h:2256
clang::UnresolvedLookupExpr
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:3097
clang::RequiresExprBodyDecl
Represents the body of a requires-expression.
Definition: DeclCXX.h:1961
clang::CXXRewrittenBinaryOperator
A rewritten comparison expression that was originally written using operator syntax.
Definition: ExprCXX.h:284
clang::StringLiteral::getNumConcatenated
unsigned getNumConcatenated() const
getNumConcatenated - Get the number of string literal tokens that were concatenated in translation ph...
Definition: Expr.h:1918
clang::OMPIteratorExpr::setIteratorKwLoc
void setIteratorKwLoc(SourceLocation L)
Definition: ExprOpenMP.h:373
clang::serialization::StmtCode
StmtCode
Record codes for each kind of statement or expression.
Definition: ASTBitCodes.h:1530
clang::TemplateArgumentListInfo
A convenient class for passing around template argument information.
Definition: TemplateBase.h:563
clang::CXXNewExpr::setOperatorNew
void setOperatorNew(FunctionDecl *D)
Definition: ExprCXX.h:2265
clang::serialization::EXPR_CXX_MEMBER_CALL
@ EXPR_CXX_MEMBER_CALL
A CXXMemberCallExpr record.
Definition: ASTBitCodes.h:1814
clang::serialization::STMT_OMP_TASKGROUP_DIRECTIVE
@ STMT_OMP_TASKGROUP_DIRECTIVE
Definition: ASTBitCodes.h:1950
clang::Decl::getAccess
AccessSpecifier getAccess() const
Definition: DeclBase.h:491
StmtOpenMP.h
clang::DeclAccessPair::make
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
Definition: DeclAccessPair.h:35
clang::CXXBoolLiteralExpr::setLocation
void setLocation(SourceLocation L)
Definition: ExprCXX.h:745
clang::CXXConstructExpr::CreateEmpty
static CXXConstructExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs)
Create an empty C++ construction expression.
Definition: ExprCXX.cpp:1049
clang::DependentCoawaitExpr
Represents a 'co_await' expression while the type of the promise is dependent.
Definition: ExprCXX.h:4855
clang::SizeOfPackExpr
Represents an expression that computes the length of a parameter pack.
Definition: ExprCXX.h:4151
clang::serialization::STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE
@ STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE
Definition: ASTBitCodes.h:1932
clang::CXXBindTemporaryExpr
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1419
clang::ShuffleVectorExpr::setExprs
void setExprs(const ASTContext &C, ArrayRef< Expr * > Exprs)
Definition: Expr.cpp:4290
clang::OverloadExpr::getNumDecls
unsigned getNumDecls() const
Gets the number of declarations in the unresolved set.
Definition: ExprCXX.h:3007
clang::serialization::EXPR_ARRAY_SUBSCRIPT
@ EXPR_ARRAY_SUBSCRIPT
An ArraySubscriptExpr record.
Definition: ASTBitCodes.h:1641
clang::CXXReinterpretCastExpr::CreateEmpty
static CXXReinterpretCastExpr * CreateEmpty(const ASTContext &Context, unsigned pathSize)
Definition: ExprCXX.cpp:811
clang::BinaryOperator
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3812
clang::ObjCSubscriptRefExpr::setKeyExpr
void setKeyExpr(Stmt *S)
Definition: ExprObjC.h:884
clang::InitListExpr::setRBraceLoc
void setRBraceLoc(SourceLocation Loc)
Definition: Expr.h:4948
clang::OMPTargetUpdateDirective::CreateEmpty
static OMPTargetUpdateDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1567
clang::OMPForDirective::CreateEmpty
static OMPForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:398
clang::OverloadExpr::getTrailingResults
DeclAccessPair * getTrailingResults()
Return the results. Defined after UnresolvedMemberExpr.
Definition: ExprCXX.h:3988
clang::ASTRecordReader::readSourceRange
SourceRange readSourceRange(LocSeq *Seq=nullptr)
Read a source range, advancing Idx.
Definition: ASTRecordReader.h:280
clang::OMPDistributeSimdDirective::CreateEmpty
static OMPDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1730
clang::TemplateArgumentListInfo::addArgument
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:603
clang::OMPTeamsDirective
This represents '#pragma omp teams' directive.
Definition: StmtOpenMP.h:3488
clang::VAArgExpr::setIsMicrosoftABI
void setIsMicrosoftABI(bool IsMS)
Definition: Expr.h:4660
hlsl::uint64_t
unsigned long uint64_t
Definition: hlsl_basic_types.h:25
clang::serialization::STMT_SEH_LEAVE
@ STMT_SEH_LEAVE
Definition: ASTBitCodes.h:1909
clang::LambdaExpr
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1872
clang::OMPLoopDirective
This is a common base class for loop directives ('omp simd', 'omp for', 'omp for simd' etc....
Definition: StmtOpenMP.h:1002
clang::FloatingLiteral::setExact
void setExact(bool E)
Definition: Expr.h:1696
clang::ObjCAtThrowStmt
Represents Objective-C's @throw statement.
Definition: StmtObjC.h:357
clang::CXXThisExpr::setImplicit
void setImplicit(bool I)
Definition: ExprCXX.h:1167
OperatorKinds.h
clang::Stmt::PredefinedExprBits
PredefinedExprBitfields PredefinedExprBits
Definition: Stmt.h:1030
clang::SourceRange::getEnd
SourceLocation getEnd() const
Definition: SourceLocation.h:220
clang::ObjCProtocolExpr::setProtocol
void setProtocol(ObjCProtocolDecl *P)
Definition: ExprObjC.h:522
clang::OMPParallelForDirective::CreateEmpty
static OMPParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:618
clang::ObjCStringLiteral
ObjCStringLiteral, used for Objective-C string literals i.e.
Definition: ExprObjC.h:52
clang::threadSafety::sx::toString
std::string toString(const til::SExpr *E)
Definition: ThreadSafetyCommon.h:91
clang::DeclAccessPair
A POD class for pairing a NamedDecl* with an access specifier.
Definition: DeclAccessPair.h:29
clang::ConceptReference::ConceptName
DeclarationNameInfo ConceptName
The concept name used.
Definition: ASTConcept.h:111
clang::Stmt::CXXDefaultInitExprBits
CXXDefaultInitExprBitfields CXXDefaultInitExprBits
Definition: Stmt.h:1059
clang::serialization::STMT_ATTRIBUTED
@ STMT_ATTRIBUTED
An AttributedStmt record.
Definition: ASTBitCodes.h:1557
clang::ConceptSpecializationExpr
Represents the specialization of a concept - evaluates to a prvalue of type bool.
Definition: ExprConcepts.h:40
clang::OMPScanDirective
This represents '#pragma omp scan' directive.
Definition: StmtOpenMP.h:5648
clang::MaterializeTemporaryExpr
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Definition: ExprCXX.h:4513
clang::serialization::EXPR_DESIGNATED_INIT_UPDATE
@ EXPR_DESIGNATED_INIT_UPDATE
A DesignatedInitUpdateExpr record.
Definition: ASTBitCodes.h:1680
clang::CXXTryStmt::Create
static CXXTryStmt * Create(const ASTContext &C, SourceLocation tryLoc, Stmt *tryBlock, ArrayRef< Stmt * > handlers)
Definition: StmtCXX.cpp:25
clang::OMPMaskedDirective::CreateEmpty
static OMPMaskedDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:2305
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:209
clang::index::SymbolRole::Implicit
@ Implicit
clang::serialization::EXPR_CXX_TYPEID_EXPR
@ EXPR_CXX_TYPEID_EXPR
Definition: ASTBitCodes.h:1859
clang::ObjCDictionaryLiteral
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
Definition: ExprObjC.h:306
clang::serialization::EXPR_CXX_STATIC_CAST
@ EXPR_CXX_STATIC_CAST
A CXXStaticCastExpr record.
Definition: ASTBitCodes.h:1829
clang::OMPMetaDirective
This represents '#pragma omp metadirective' directive.
Definition: StmtOpenMP.h:5870
NestedNameSpecifier.h
LangOptions.h
clang::serialization::EXPR_OBJC_AVAILABILITY_CHECK
@ EXPR_OBJC_AVAILABILITY_CHECK
An ObjCAvailabilityCheckExpr record.
Definition: ASTBitCodes.h:1797
clang::OMPParallelMaskedTaskLoopSimdDirective
This represents '#pragma omp parallel masked taskloop simd' directive.
Definition: StmtOpenMP.h:4304
clang::Stmt::MemberExprBits
MemberExprBitfields MemberExprBits
Definition: Stmt.h:1039
clang::CXXConstructExpr::setArg
void setArg(unsigned Arg, Expr *ArgExpr)
Set the specified argument.
Definition: ExprCXX.h:1628
clang::ImplicitCastExpr::setIsPartOfExplicitCast
void setIsPartOfExplicitCast(bool PartOfExplicitCast)
Definition: Expr.h:3659
clang::Stmt::StmtExprBits
StmtExprBitfields StmtExprBits
Definition: Stmt.h:1049
clang::OMPCriticalDirective::CreateEmpty
static OMPCriticalDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:573
clang::serialization::STMT_OMP_TILE_DIRECTIVE
@ STMT_OMP_TILE_DIRECTIVE
Definition: ASTBitCodes.h:1919
clang::CallExpr::setArg
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
Definition: Expr.h:3014
clang::BinaryOperator::setRHS
void setRHS(Expr *E)
Definition: Expr.h:3864
clang::serialization::EXPR_CXX_BIND_TEMPORARY
@ EXPR_CXX_BIND_TEMPORARY
Definition: ASTBitCodes.h:1865
clang::concepts::NestedRequirement
A requires-expression requirement which is satisfied when a general constraint expression is satisfie...
Definition: ExprConcepts.h:403
TypeTraits.h
clang::Stmt::CXXConstructExprBits
CXXConstructExprBitfields CXXConstructExprBits
Definition: Stmt.h:1065
clang::OMPIteratorHelperData::CounterUpdate
Expr * CounterUpdate
Updater for the internal counter: ++CounterVD;.
Definition: ExprOpenMP.h:245
clang::ConceptReference::NamedConcept
ConceptDecl * NamedConcept
The concept named.
Definition: ASTConcept.h:120
clang::BuiltinBitCastExpr
Represents a C++2a __builtin_bit_cast(T, v) expression.
Definition: ExprCXX.h:4928
clang::ExprWithCleanups::CleanupObject
llvm::PointerUnion< BlockDecl *, CompoundLiteralExpr * > CleanupObject
The type of objects that are kept in the cleanup.
Definition: ExprCXX.h:3376
clang::serialization::STMT_OMP_FOR_SIMD_DIRECTIVE
@ STMT_OMP_FOR_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1922
clang::serialization::EXPR_SOURCE_LOC
@ EXPR_SOURCE_LOC
A SourceLocExpr record.
Definition: ASTBitCodes.h:1710
clang::serialization::STMT_DO
@ STMT_DO
A DoStmt record.
Definition: ASTBitCodes.h:1569
clang::OMPParallelMaskedTaskLoopDirective
This represents '#pragma omp parallel masked taskloop' directive.
Definition: StmtOpenMP.h:4159
clang::TemplateArgument
Represents a template argument.
Definition: TemplateBase.h:61
clang::CharacterLiteral::setKind
void setKind(CharacterKind kind)
Definition: Expr.h:1630
clang::serialization::STMT_OMP_PARALLEL_MASKED_TASKLOOP_SIMD_DIRECTIVE
@ STMT_OMP_PARALLEL_MASKED_TASKLOOP_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1962
OpenMPKinds.h
clang::serialization::EXPR_IMPLICIT_CAST
@ EXPR_IMPLICIT_CAST
An ImplicitCastExpr record.
Definition: ASTBitCodes.h:1662
clang::concepts::Requirement
A static requirement that can be used in a requires-expression to check properties of types and expre...
Definition: ExprConcepts.h:145
clang::OMPDistributeParallelForSimdDirective
This represents '#pragma omp distribute parallel for simd' composite directive.
Definition: StmtOpenMP.h:4587
clang::SwitchStmt::CreateEmpty
static SwitchStmt * CreateEmpty(const ASTContext &Ctx, bool HasInit, bool HasVar)
Create an empty switch statement optionally with storage for an init expression and a condition varia...
Definition: Stmt.cpp:1089
clang::ASTStmtReader
Definition: ASTReaderStmt.cpp:71
clang::CastExpr::path_begin
path_iterator path_begin()
Definition: Expr.h:3550
clang::ObjCMessageExpr::setSelector
void setSelector(Selector S)
Definition: ExprObjC.h:1341
clang::serialization::STMT_OMP_PARALLEL_DIRECTIVE
@ STMT_OMP_PARALLEL_DIRECTIVE
Definition: ASTBitCodes.h:1917
clang::DesignatedInitUpdateExpr::setBase
void setBase(Expr *Base)
Definition: Expr.h:5392
clang::ForStmt
ForStmt - This represents a 'for (init;cond;inc)' stmt.
Definition: Stmt.h:2570
clang::ObjCAvailabilityCheckExpr
A runtime availability query.
Definition: ExprObjC.h:1686
clang::CXXFunctionalCastExpr::setLParenLoc
void setLParenLoc(SourceLocation L)
Definition: ExprCXX.h:1774
clang::serialization::STMT_OBJC_AT_TRY
@ STMT_OBJC_AT_TRY
An ObjCAtTryStmt record.
Definition: ASTBitCodes.h:1782
clang::OMPDepobjDirective
This represents '#pragma omp depobj' directive.
Definition: StmtOpenMP.h:2788
clang::CastExpr::hasStoredFPFeatures
bool hasStoredFPFeatures() const
Definition: Expr.h:3567
clang::ASTRecordReader::readString
std::string readString()
Read a string, advancing Idx.
Definition: ASTRecordReader.h:310
clang::serialization::STMT_OBJC_FOR_COLLECTION
@ STMT_OBJC_FOR_COLLECTION
An ObjCForCollectionStmt record.
Definition: ASTBitCodes.h:1773
clang::CXXNullPtrLiteralExpr::setLocation
void setLocation(SourceLocation L)
Definition: ExprCXX.h:781
clang::serialization::STMT_CXX_CATCH
@ STMT_CXX_CATCH
A CXXCatchStmt record.
Definition: ASTBitCodes.h:1802
clang::ASTTemplateKWAndArgsInfo::initializeFrom
void initializeFrom(SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &List, TemplateArgumentLoc *OutArgArray)
Definition: TemplateBase.cpp:643
clang::Stmt::CXXRewrittenBinaryOperatorBits
CXXRewrittenBinaryOperatorBitfields CXXRewrittenBinaryOperatorBits
Definition: Stmt.h:1053
clang::PseudoObjectExpr
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:6105
clang::ObjCAtSynchronizedStmt
Represents Objective-C's @synchronized statement.
Definition: StmtObjC.h:302
clang::ObjCMessageExpr::getReceiverKind
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
Definition: ExprObjC.h:1224
clang::DesignatedInitExpr::getNumSubExprs
unsigned getNumSubExprs() const
Retrieve the total number of subexpressions in this designated initializer expression,...
Definition: Expr.h:5287
clang::serialization::EXPR_ASTYPE
@ EXPR_ASTYPE
Definition: ASTBitCodes.h:1902
clang::IntegerLiteral::Create
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Definition: Expr.cpp:982
clang::InitListExpr::setLBraceLoc
void setLBraceLoc(SourceLocation Loc)
Definition: Expr.h:4946
clang::UnaryOperator::setOpcode
void setOpcode(Opcode Opc)
Definition: Expr.h:2217
clang::index::SymbolKind::Field
@ Field
clang::ChooseExpr::setRHS
void setRHS(Expr *E)
Definition: Expr.h:4574
clang::BinaryConditionalOperator
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition: Expr.h:4212
clang::CXXNewExpr::raw_arg_end
raw_arg_iterator raw_arg_end()
Definition: ExprCXX.h:2392
clang::ParenListExpr::getNumExprs
unsigned getNumExprs() const
Return the number of expressions in this paren list.
Definition: Expr.h:5568
clang::serialization::EXPR_BUILTIN_BIT_CAST
@ EXPR_BUILTIN_BIT_CAST
A BuiltinBitCastExpr record.
Definition: ASTBitCodes.h:1847
clang::InitListExpr::updateInit
Expr * updateInit(const ASTContext &C, unsigned Init, Expr *expr)
Updates the initializer at index Init with the new expression expr, and returns the old expression at...
Definition: Expr.cpp:2372
clang::CapturedStmt::VariableCaptureKind
VariableCaptureKind
The different capture forms: by 'this', by reference, capture for variable-length array type etc.
Definition: Stmt.h:3540
clang::DeclRefExpr::getDecl
ValueDecl * getDecl()
Definition: Expr.h:1304
clang::TemplateArgumentLoc
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:457
clang::OMPTargetTeamsDirective::CreateEmpty
static OMPTargetTeamsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:2038
Type.h
clang::ExtVectorElementExpr::setAccessor
void setAccessor(IdentifierInfo *II)
Definition: Expr.h:5937
clang::Stmt::RequiresExprBits
RequiresExprBitfields RequiresExprBits
Definition: Stmt.h:1075
clang::OMPAtomicDirective::CreateEmpty
static OMPAtomicDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:916
clang::Expr::isInstantiationDependent
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
Definition: Expr.h:214
clang::ObjCMessageExpr::Class
@ Class
The receiver is a class.
Definition: ExprObjC.h:1088
clang::ObjCMessageExpr::setDelegateInitCall
void setDelegateInitCall(bool isDelegate)
Definition: ExprObjC.h:1404
clang::OMPLoopBasedDirective
The base class for all loop-based directives, including loop transformation directives.
Definition: StmtOpenMP.h:682
Expr.h
clang::serialization::EXPR_CONCEPT_SPECIALIZATION
@ EXPR_CONCEPT_SPECIALIZATION
Definition: ASTBitCodes.h:1895
clang::ImplicitValueInitExpr
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:5515
bool
#define bool
Definition: stdbool.h:20
clang::CXXBindTemporaryExpr::setSubExpr
void setSubExpr(Expr *E)
Definition: ExprCXX.h:1443
clang::serialization::STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE
@ STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1968
clang::TemplateArgumentListInfo::setLAngleLoc
void setLAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:582
clang::OMPParallelDirective
This represents '#pragma omp parallel' directive.
Definition: StmtOpenMP.h:611
ASTContext.h
clang::UnresolvedSet< 8 >
clang::CStyleCastExpr::setLParenLoc
void setLParenLoc(SourceLocation L)
Definition: Expr.h:3776
clang::serialization::DesignatorTypes
DesignatorTypes
The kinds of designators that can occur in a DesignatedInitExpr.
Definition: ASTBitCodes.h:2011
clang::CXXDynamicCastExpr
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Definition: ExprCXX.h:477
clang::OMPLoopTransformationDirective::setNumGeneratedLoops
void setNumGeneratedLoops(unsigned Num)
Set the number of loops generated by this loop transformation.
Definition: StmtOpenMP.h:974
clang::OMPParallelForSimdDirective
This represents '#pragma omp parallel for simd' directive.
Definition: StmtOpenMP.h:2191
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:906
clang::ObjCAtTryStmt::CreateEmpty
static ObjCAtTryStmt * CreateEmpty(const ASTContext &Context, unsigned NumCatchStmts, bool HasFinally)
Definition: StmtObjC.cpp:56
clang::OMPTaskDirective
This represents '#pragma omp task' directive.
Definition: StmtOpenMP.h:2464
clang::OffsetOfExpr::getNumComponents
unsigned getNumComponents() const
Definition: Expr.h:2512
clang::FloatingLiteral::setLocation
void setLocation(SourceLocation L)
Definition: Expr.h:1704
clang::OffsetOfExpr::setTypeSourceInfo
void setTypeSourceInfo(TypeSourceInfo *tsi)
Definition: Expr.h:2498
clang::CapturedStmt::CreateDeserialized
static CapturedStmt * CreateDeserialized(const ASTContext &Context, unsigned NumCaptures)
Definition: Stmt.cpp:1377
clang::ObjCIsaExpr::setBase
void setBase(Expr *E)
Definition: ExprObjC.h:1506
clang::TemplateParameterList
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:70
clang::StringLiteral
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1776
clang::serialization::STMT_CORETURN
@ STMT_CORETURN
Definition: ASTBitCodes.h:1997
clang::OMPTargetParallelDirective
This represents '#pragma omp target parallel' directive.
Definition: StmtOpenMP.h:3313
clang::serialization::STMT_OMP_CANCEL_DIRECTIVE
@ STMT_OMP_CANCEL_DIRECTIVE
Definition: ASTBitCodes.h:1952
clang::ExprWithCleanups
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
Definition: ExprCXX.h:3366
clang::serialization::STMT_OMP_TARGET_PARALLEL_DIRECTIVE
@ STMT_OMP_TARGET_PARALLEL_DIRECTIVE
Definition: ASTBitCodes.h:1947
clang::CapturedStmt
This captures a statement into a function.
Definition: Stmt.h:3536
clang::ObjCAtFinallyStmt
Represents Objective-C's @finally statement.
Definition: StmtObjC.h:127
OperationKinds.h
clang::OMPParallelForDirective
This represents '#pragma omp parallel for' directive.
Definition: StmtOpenMP.h:2094
clang::serialization::STMT_OMP_SCAN_DIRECTIVE
@ STMT_OMP_SCAN_DIRECTIVE
Definition: ASTBitCodes.h:1940
clang::serialization::STMT_OMP_PARALLEL_GENERIC_LOOP_DIRECTIVE
@ STMT_OMP_PARALLEL_GENERIC_LOOP_DIRECTIVE
Definition: ASTBitCodes.h:1985
clang::DesignatedInitExpr::setEqualOrColonLoc
void setEqualOrColonLoc(SourceLocation L)
Definition: Expr.h:5263
clang::serialization::EXPR_UNARY_OPERATOR
@ EXPR_UNARY_OPERATOR
A UnaryOperator record.
Definition: ASTBitCodes.h:1632
clang::ObjCSelectorExpr::setSelector
void setSelector(Selector S)
Definition: ExprObjC.h:469
clang::OpaqueValueExpr::setIsUnique
void setIsUnique(bool V)
Definition: Expr.h:1196
clang::ImaginaryLiteral::setSubExpr
void setSubExpr(Expr *E)
Definition: Expr.h:1741
clang::serialization::STMT_OMP_DISPATCH_DIRECTIVE
@ STMT_OMP_DISPATCH_DIRECTIVE
Definition: ASTBitCodes.h:1980
clang::OMPParallelSectionsDirective::CreateEmpty
static OMPParallelSectionsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:713
clang::serialization::EXPR_OMP_ARRAY_SHAPING
@ EXPR_OMP_ARRAY_SHAPING
Definition: ASTBitCodes.h:1988
clang::ObjCIvarRefExpr::setBase
void setBase(Expr *base)
Definition: ExprObjC.h:582
clang::CStyleCastExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: Expr.h:3779
clang::CXXTryStmt
CXXTryStmt - A C++ try block, including all handlers.
Definition: StmtCXX.h:68
clang::SwitchCase
Definition: Stmt.h:1558
ExprObjC.h
clang::NestedNameSpecifierLoc
A C++ nested-name-specifier augmented with source location information.
Definition: NestedNameSpecifier.h:243
clang::serialization::STMT_BREAK
@ STMT_BREAK
A BreakStmt record.
Definition: ASTBitCodes.h:1584
ExprCXX.h
clang::serialization::STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE
@ STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1967
clang::OMPMasterDirective::CreateEmpty
static OMPMasterDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:558
Base
clang::serialization::STMT_OMP_TEAMS_DIRECTIVE
@ STMT_OMP_TEAMS_DIRECTIVE
Definition: ASTBitCodes.h:1949
clang::FixedPointLiteral::setScale
void setScale(unsigned S)
Definition: Expr.h:1576
clang::ReturnStmt::CreateEmpty
static ReturnStmt * CreateEmpty(const ASTContext &Ctx, bool HasNRVOCandidate)
Create an empty return statement, optionally with storage for an NRVO candidate.
Definition: Stmt.cpp:1209
clang::ObjCEncodeExpr
ObjCEncodeExpr, used for @encode in Objective-C.
Definition: ExprObjC.h:409
clang::serialization::STMT_NULL_PTR
@ STMT_NULL_PTR
A NULL expression.
Definition: ASTBitCodes.h:1536
clang::CXXInheritedCtorInitExpr
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition: ExprCXX.h:1658
clang::CXXDefaultArgExpr
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:1248
clang::serialization::STMT_RETURN
@ STMT_RETURN
A ReturnStmt record.
Definition: ASTBitCodes.h:1587
clang::PackExpansionExpr
Represents a C++11 pack expansion that produces a sequence of expressions.
Definition: ExprCXX.h:4075
clang::CastExpr::path_size
unsigned path_size() const
Definition: Expr.h:3549
clang::concepts::TypeRequirement::SatisfactionStatus
SatisfactionStatus
Definition: ExprConcepts.h:201
clang::UnaryExprOrTypeTraitExpr::setArgument
void setArgument(Expr *E)
Definition: Expr.h:2616
clang::IfStmt::CreateEmpty
static IfStmt * CreateEmpty(const ASTContext &Ctx, bool HasElse, bool HasVar, bool HasInit)
Create an empty IfStmt optionally with storage for an else statement, condition variable and init exp...
Definition: Stmt.cpp:970
clang::OMPCriticalDirective
This represents '#pragma omp critical' directive.
Definition: StmtOpenMP.h:2023
clang::DeclRefExpr::hasQualifier
bool hasQualifier() const
Determine whether this declaration reference was preceded by a C++ nested-name-specifier,...
Definition: Expr.h:1319
clang::AtomicExpr::AtomicOp
AtomicOp
Definition: Expr.h:6241
clang::OMPTargetTeamsGenericLoopDirective
This represents '#pragma omp target teams loop' directive.
Definition: StmtOpenMP.h:6036
ASTConcept.h
This file provides AST data structures related to concepts.
clang::OMPTargetParallelForSimdDirective
This represents '#pragma omp target parallel for simd' directive.
Definition: StmtOpenMP.h:4718
DeclGroup.h
clang::CompoundLiteralExpr::setTypeSourceInfo
void setTypeSourceInfo(TypeSourceInfo *tinfo)
Definition: Expr.h:3446
clang::serialization::EXPR_OBJC_ISA
@ EXPR_OBJC_ISA
An ObjCIsa Expr record.
Definition: ASTBitCodes.h:1767
clang::ObjCIvarRefExpr::setLocation
void setLocation(SourceLocation L)
Definition: ExprObjC.h:590
clang::OMPMasterTaskLoopDirective
This represents '#pragma omp master taskloop' directive.
Definition: StmtOpenMP.h:3798
clang::serialization::EXPR_SYCL_UNIQUE_STABLE_NAME
@ EXPR_SYCL_UNIQUE_STABLE_NAME
Definition: ASTBitCodes.h:2006
clang::BlockExpr::setBlockDecl
void setBlockDecl(BlockDecl *BD)
Definition: Expr.h:5989
clang::concepts::Requirement::RK_Compound
@ RK_Compound
Definition: ExprConcepts.h:149
clang::ConstantExpr
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
Definition: Expr.h:1041
clang::serialization::EXPR_DECL_REF
@ EXPR_DECL_REF
A DeclRefExpr record.
Definition: ASTBitCodes.h:1608
clang::concepts::Requirement::RK_Simple
@ RK_Simple
Definition: ExprConcepts.h:149
clang::serialization::EXPR_MEMBER
@ EXPR_MEMBER
A MemberExpr record.
Definition: ASTBitCodes.h:1650
clang::serialization::EXPR_REQUIRES
@ EXPR_REQUIRES
Definition: ASTBitCodes.h:1896
clang::ObjCMessageExpr
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:940
clang::OMPTeamsDistributeDirective
This represents '#pragma omp teams distribute' directive.
Definition: StmtOpenMP.h:4850
clang::serialization::COK_Block
@ COK_Block
Definition: ASTBitCodes.h:2036
clang::OMPTargetParallelForDirective::CreateEmpty
static OMPTargetParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:995
clang::OffsetOfNode
Helper class for OffsetOfExpr.
Definition: Expr.h:2349
clang::serialization::STMT_COROUTINE_BODY
@ STMT_COROUTINE_BODY
Definition: ASTBitCodes.h:1996
clang::serialization::EXPR_CXX_REWRITTEN_BINARY_OPERATOR
@ EXPR_CXX_REWRITTEN_BINARY_OPERATOR
A CXXRewrittenBinaryOperator record.
Definition: ASTBitCodes.h:1817
clang::ASTRecordReader::readDecl
Decl * readDecl()
Reads a declaration from the given position in a record in the given module, advancing Idx.
Definition: ASTRecordReader.h:193
clang::FullExpr::SubExpr
Stmt * SubExpr
Definition: Expr.h:1015
StmtObjC.h
clang::serialization::STMT_OMP_TARGET_TEAMS_GENERIC_LOOP_DIRECTIVE
@ STMT_OMP_TARGET_TEAMS_GENERIC_LOOP_DIRECTIVE
Definition: ASTBitCodes.h:1984
clang::ChooseExpr
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:4529
clang::serialization::EXPR_CXX_REINTERPRET_CAST
@ EXPR_CXX_REINTERPRET_CAST
A CXXReinterpretCastExpr record.
Definition: ASTBitCodes.h:1835
clang::ObjCIsaExpr::setOpLoc
void setOpLoc(SourceLocation L)
Definition: ExprObjC.h:1518
clang::ConstraintSatisfaction::IsSatisfied
bool IsSatisfied
Definition: ASTConcept.h:46
clang::ObjCMessageExpr::ReceiverKind
ReceiverKind
The kind of receiver this message is sending to.
Definition: ExprObjC.h:1086
clang::ConceptReference::ArgsAsWritten
const ASTTemplateArgumentListInfo * ArgsAsWritten
The template argument list source info used to specialize the concept.
Definition: ASTConcept.h:124
clang::SEHExceptStmt
Definition: Stmt.h:3365
clang::InitListExpr::sawArrayRangeDesignator
void sawArrayRangeDesignator(bool ARD=true)
Definition: Expr.h:4971
clang::OMPTaskyieldDirective::CreateEmpty
static OMPTaskyieldDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:742
clang::OMPArrayShapingExpr
An explicit cast in C or a C-style cast in C++, which uses the syntax ([s1][s2]......
Definition: ExprOpenMP.h:146
clang::Stmt::CXXDefaultArgExprBits
CXXDefaultArgExprBitfields CXXDefaultArgExprBits
Definition: Stmt.h:1058
clang::serialization::EXPR_BLOCK
@ EXPR_BLOCK
BlockExpr.
Definition: ASTBitCodes.h:1719
clang::MatrixSubscriptExpr::setRBracketLoc
void setRBracketLoc(SourceLocation L)
Definition: Expr.h:2787
clang::ASTReader::ReadSubExpr
Expr * ReadSubExpr()
Reads a sub-expression operand during statement reading.
Definition: ASTReaderStmt.cpp:2704
clang::serialization::EXPR_CXX_THROW
@ EXPR_CXX_THROW
Definition: ASTBitCodes.h:1862
clang::OMPMetaDirective::CreateEmpty
static OMPMetaDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Definition: StmtOpenMP.cpp:273
clang::serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE
@ STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE
Definition: ASTBitCodes.h:1976
clang::serialization::EXPR_CXX_FOLD
@ EXPR_CXX_FOLD
Definition: ASTBitCodes.h:1894
clang::serialization::STMT_INDIRECT_GOTO
@ STMT_INDIRECT_GOTO
An IndirectGotoStmt record.
Definition: ASTBitCodes.h:1578
clang::ObjCDictionaryLiteral_ExpansionData
Internal struct to describes an element that is a pack expansion, used if any of the elements in the ...
Definition: ExprObjC.h:294
clang::UnaryExprOrTypeTraitExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: Expr.h:2635
clang::GenericSelectionExpr::CreateEmpty
static GenericSelectionExpr * CreateEmpty(const ASTContext &Context, unsigned NumAssocs)
Create an empty generic selection expression for deserialization.
Definition: Expr.cpp:4378
clang::serialization::STMT_DEFAULT
@ STMT_DEFAULT
A DefaultStmt record.
Definition: ASTBitCodes.h:1551
clang::serialization::STMT_OMP_TARGET_DIRECTIVE
@ STMT_OMP_TARGET_DIRECTIVE
Definition: ASTBitCodes.h:1943
clang::OMPTargetTeamsDistributeDirective::CreateEmpty
static OMPTargetTeamsDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:2080
clang::serialization::STMT_OMP_PARALLEL_MASKED_DIRECTIVE
@ STMT_OMP_PARALLEL_MASKED_DIRECTIVE
Definition: ASTBitCodes.h:1931
clang::CharacterLiteral
Definition: Expr.h:1593
clang::OMPScanDirective::CreateEmpty
static OMPScanDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:873
clang::UserDefinedLiteral
A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit....
Definition: ExprCXX.h:638
clang::CXXTypeidExpr::setSourceRange
void setSourceRange(SourceRange R)
Definition: ExprCXX.h:901
clang::BinaryOperator::setLHS
void setLHS(Expr *E)
Definition: Expr.h:3862
clang::CompoundAssignOperator::CreateEmpty
static CompoundAssignOperator * CreateEmpty(const ASTContext &C, bool hasFPFeatures)
Definition: Expr.cpp:4640
clang::OMPMaskedTaskLoopDirective
This represents '#pragma omp masked taskloop' directive.
Definition: StmtOpenMP.h:3874
clang::OMPTargetSimdDirective::CreateEmpty
static OMPTargetSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1813
clang::ChooseExpr::setIsConditionTrue
void setIsConditionTrue(bool isTrue)
Definition: Expr.h:4557
clang::serialization::EXPR_CXX_EXPRESSION_TRAIT
@ EXPR_CXX_EXPRESSION_TRAIT
Definition: ASTBitCodes.h:1880
clang::AddrLabelExpr::setLabelLoc
void setLabelLoc(SourceLocation L)
Definition: Expr.h:4327
clang::serialization::STMT_OMP_DEPOBJ_DIRECTIVE
@ STMT_OMP_DEPOBJ_DIRECTIVE
Definition: ASTBitCodes.h:1939
clang::transformer::EditKind::Range
@ Range
clang::MemberExpr::CreateEmpty
static MemberExpr * CreateEmpty(const ASTContext &Context, bool HasQualifier, bool HasFoundDecl, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
Definition: Expr.cpp:1769
clang::GNUNullExpr::setTokenLocation
void setTokenLocation(SourceLocation L)
Definition: Expr.h:4619
clang::serialization::EXPR_PAREN_LIST
@ EXPR_PAREN_LIST
A ParenListExpr record.
Definition: ASTBitCodes.h:1629
clang::OMPCancelDirective
This represents '#pragma omp cancel' directive.
Definition: StmtOpenMP.h:3599
clang::CompoundLiteralExpr
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:3410
clang::OMPTeamsDistributeParallelForSimdDirective::CreateEmpty
static OMPTeamsDistributeParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1957
clang::serialization::EXPR_SIZEOF_ALIGN_OF
@ EXPR_SIZEOF_ALIGN_OF
A SizefAlignOfExpr record.
Definition: ASTBitCodes.h:1638
clang::MatrixSubscriptExpr::setRowIdx
void setRowIdx(Expr *E)
Definition: Expr.h:2764
ASTBitCodes.h
clang::serialization::EXPR_SIZEOF_PACK
@ EXPR_SIZEOF_PACK
Definition: ASTBitCodes.h:1889
clang::OMPSectionsDirective
This represents '#pragma omp sections' directive.
Definition: StmtOpenMP.h:1785
clang::OffsetOfNode::Kind
Kind
The kind of offsetof node we have.
Definition: Expr.h:2352
clang::AccessSpecifier
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:111
clang::serialization::EXPR_FUNCTION_PARM_PACK
@ EXPR_FUNCTION_PARM_PACK
Definition: ASTBitCodes.h:1892
clang::OMPTargetTeamsDistributeParallelForSimdDirective
This represents '#pragma omp target teams distribute parallel for simd' combined directive.
Definition: StmtOpenMP.h:5363
clang::OMPMaskedTaskLoopSimdDirective
This represents '#pragma omp masked taskloop simd' directive.
Definition: StmtOpenMP.h:4015
clang::CStyleCastExpr
CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr....
Definition: Expr.h:3740
clang::APIntStorage::setValue
void setValue(const ASTContext &C, const llvm::APInt &Val)
Definition: Expr.h:1488
clang::CallExpr::ADLCallKind
ADLCallKind
Definition: Expr.h:2866
clang::CallExpr::setCallee
void setCallee(Expr *F)
Definition: Expr.h:2962
clang::serialization::EXPR_MATRIX_SUBSCRIPT
@ EXPR_MATRIX_SUBSCRIPT
An MatrixSubscriptExpr record.
Definition: ASTBitCodes.h:1644
clang::Stmt::CXXDependentScopeMemberExprBits
CXXDependentScopeMemberExprBitfields CXXDependentScopeMemberExprBits
Definition: Stmt.h:1068
clang::GCCAsmStmt
This represents a GCC inline-assembly statement extension.
Definition: Stmt.h:3038
clang::OverloadExpr::getNumTemplateArgs
unsigned getNumTemplateArgs() const
Definition: ExprCXX.h:3063
clang::serialization::EXPR_CXX_OPERATOR_CALL
@ EXPR_CXX_OPERATOR_CALL
A CXXOperatorCallExpr record.
Definition: ASTBitCodes.h:1811
clang::CStyleCastExpr::CreateEmpty
static CStyleCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize, bool HasFPFeatures)
Definition: Expr.cpp:2111
SourceLocation.h
clang::StringLiteral::getKind
StringKind getKind() const
Definition: Expr.h:1891
clang::serialization::STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE
@ STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE
Definition: ASTBitCodes.h:1945
clang::OMPFlushDirective
This represents '#pragma omp flush' directive.
Definition: StmtOpenMP.h:2736
clang::ObjCMessageExpr::setInstanceReceiver
void setInstanceReceiver(Expr *rec)
Turn this message send into an instance message that computes the receiver object with the given expr...
Definition: ExprObjC.h:1262
clang::AsmStmt
AsmStmt is the base class for GCCAsmStmt and MSAsmStmt.
Definition: Stmt.h:2879
clang::serialization::EXPR_BINARY_OPERATOR
@ EXPR_BINARY_OPERATOR
A BinaryOperator record.
Definition: ASTBitCodes.h:1653
clang::OMPTargetEnterDataDirective
This represents '#pragma omp target enter data' directive.
Definition: StmtOpenMP.h:3204
clang::ConceptReference::NestedNameSpec
NestedNameSpecifierLoc NestedNameSpec
Definition: ASTConcept.h:104
clang::DesignatedInitUpdateExpr
Definition: Expr.h:5372
clang::serialization::STMT_OMP_FLUSH_DIRECTIVE
@ STMT_OMP_FLUSH_DIRECTIVE
Definition: ASTBitCodes.h:1938
readConstraintSatisfaction
static ConstraintSatisfaction readConstraintSatisfaction(ASTRecordReader &Record)
Definition: ASTReaderStmt.cpp:772
clang::serialization::STMT_SEH_TRY
@ STMT_SEH_TRY
Definition: ASTBitCodes.h:1912
clang::serialization::EXPR_CXX_NULL_PTR_LITERAL
@ EXPR_CXX_NULL_PTR_LITERAL
Definition: ASTBitCodes.h:1858
clang::OffsetOfExpr::setIndexExpr
void setIndexExpr(unsigned Idx, Expr *E)
Definition: Expr.h:2526
clang::CXXUuidofExpr::setSourceRange
void setSourceRange(SourceRange R)
Definition: ExprCXX.h:1114
clang::ParenExpr::setSubExpr
void setSubExpr(Expr *E)
Definition: Expr.h:2138
clang::OMPArraySectionExpr::setStride
void setStride(Expr *E)
Set length of the array section.
Definition: ExprOpenMP.h:111
clang::OMPInteropDirective
This represents '#pragma omp interop' directive.
Definition: StmtOpenMP.h:5701
clang::serialization::DESIG_ARRAY
@ DESIG_ARRAY
Array designator.
Definition: ASTBitCodes.h:2020
clang::OMPArraySectionExpr::setLength
void setLength(Expr *E)
Set length of the array section.
Definition: ExprOpenMP.h:105
clang::OMPTargetDataDirective::CreateEmpty
static OMPTargetDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:1011
clang::OMPIteratorHelperData::Upper
Expr * Upper
Normalized upper bound.
Definition: ExprOpenMP.h:240
clang::DesignatedInitExpr::setGNUSyntax
void setGNUSyntax(bool GNU)
Definition: Expr.h:5272
clang::serialization::STMT_IF
@ STMT_IF
An IfStmt record.
Definition: ASTBitCodes.h:1560
clang::LambdaExpr::capture_init_end
capture_init_iterator capture_init_end()
Retrieve the iterator pointing one past the last initialization argument for this lambda expression.
Definition: ExprCXX.h:2011
clang::OMPDistributeDirective
This represents '#pragma omp distribute' directive.
Definition: StmtOpenMP.h:4369
clang::serialization::DESIG_FIELD_NAME
@ DESIG_FIELD_NAME
Field designator where only the field name is known.
Definition: ASTBitCodes.h:2013
clang::OMPTeamsGenericLoopDirective
This represents '#pragma omp teams loop' directive.
Definition: StmtOpenMP.h:5971
clang::concepts::TypeRequirement
A requires-expression requirement which queries the existence of a type name or type template special...
Definition: ExprConcepts.h:199
clang::OMPDispatchDirective::CreateEmpty
static OMPDispatchDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:2287
clang::serialization::STMT_OMP_TASKYIELD_DIRECTIVE
@ STMT_OMP_TASKYIELD_DIRECTIVE
Definition: ASTBitCodes.h:1934
clang::ValueDecl
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:701
clang::serialization::STMT_OMP_TARGET_PARALLEL_GENERIC_LOOP_DIRECTIVE
@ STMT_OMP_TARGET_PARALLEL_GENERIC_LOOP_DIRECTIVE
Definition: ASTBitCodes.h:1986
clang::OMPSingleDirective
This represents '#pragma omp single' directive.
Definition: StmtOpenMP.h:1924
clang::serialization::STMT_OBJC_CATCH
@ STMT_OBJC_CATCH
An ObjCAtCatchStmt record.
Definition: ASTBitCodes.h:1776
clang::OMPTaskwaitDirective::CreateEmpty
static OMPTaskwaitDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:782
clang::ParenExpr
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:2121
clang::UnaryOperator::setSubExpr
void setSubExpr(Expr *E)
Definition: Expr.h:2220
clang::CoyieldExpr
Represents a 'co_yield' expression.
Definition: ExprCXX.h:4904
clang::serialization::EXPR_CXX_ADDRSPACE_CAST
@ EXPR_CXX_ADDRSPACE_CAST
A CXXAddrspaceCastExpr record.
Definition: ASTBitCodes.h:1841
clang::serialization::STMT_CXX_FOR_RANGE
@ STMT_CXX_FOR_RANGE
A CXXForRangeStmt record.
Definition: ASTBitCodes.h:1808
clang::ImplicitConceptSpecializationDecl
Definition: DeclTemplate.h:3309
clang::serialization::STMT_OMP_MASKED_TASKLOOP_SIMD_DIRECTIVE
@ STMT_OMP_MASKED_TASKLOOP_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1960
clang::ObjCProtocolExpr
ObjCProtocolExpr used for protocol expression in Objective-C.
Definition: ExprObjC.h:504
clang::OMPCanonicalLoop::createEmpty
static OMPCanonicalLoop * createEmpty(const ASTContext &Ctx)
Create an empty OMPCanonicalLoop for deserialization.
Definition: StmtOpenMP.h:176
clang::OMPParallelForSimdDirective::CreateEmpty
static OMPParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:661
clang::CallExpr::getNumArgs
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition: Expr.h:2988
clang::UserDefinedLiteral::CreateEmpty
static UserDefinedLiteral * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPOptions, EmptyShell Empty)
Definition: ExprCXX.cpp:906
clang::OMPForSimdDirective::CreateEmpty
static OMPForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:485
clang::serialization::EXPR_EXPR_WITH_CLEANUPS
@ EXPR_EXPR_WITH_CLEANUPS
Definition: ASTBitCodes.h:1872
clang::OMPArraySectionExpr::setBase
void setBase(Expr *E)
Set base of the array section.
Definition: ExprOpenMP.h:88
clang::serialization::EXPR_OBJC_INDIRECT_COPY_RESTORE
@ EXPR_OBJC_INDIRECT_COPY_RESTORE
An ObjCIndirectCopyRestoreExpr record.
Definition: ASTBitCodes.h:1770
clang::DesignatedInitExpr::setDesignators
void setDesignators(const ASTContext &C, const Designator *Desigs, unsigned NumDesigs)
Definition: Expr.cpp:4451
clang::OMPBarrierDirective::CreateEmpty
static OMPBarrierDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:768
clang::CXXDeleteExpr
Represents a delete expression for memory deallocation and destructor calls, e.g.
Definition: ExprCXX.h:2422
Begin
SourceLocation Begin
Definition: USRLocFinder.cpp:165
clang::CXXTemporaryObjectExpr::CreateEmpty
static CXXTemporaryObjectExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs)
Definition: ExprCXX.cpp:1015
clang::CXXAddrspaceCastExpr::CreateEmpty
static CXXAddrspaceCastExpr * CreateEmpty(const ASTContext &Context)
Definition: ExprCXX.cpp:838
clang::BlockExpr
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:5975
clang::OMPParallelMasterTaskLoopSimdDirective::CreateEmpty
static OMPParallelMasterTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1458
clang::StmtExpr
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition: Expr.h:4354
clang::UnresolvedLookupExpr::CreateEmpty
static UnresolvedLookupExpr * CreateEmpty(const ASTContext &Context, unsigned NumResults, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
Definition: ExprCXX.cpp:401
clang::OMPTaskLoopDirective
This represents '#pragma omp taskloop' directive.
Definition: StmtOpenMP.h:3659
clang::MSPropertySubscriptExpr::setRBracketLoc
void setRBracketLoc(SourceLocation L)
Definition: ExprCXX.h:1039
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:83
clang::serialization::EXPR_INIT_LIST
@ EXPR_INIT_LIST
An InitListExpr record.
Definition: ASTBitCodes.h:1674
clang::CXXTypeidExpr::isTypeOperand
bool isTypeOperand() const
Definition: ExprCXX.h:882
clang::serialization::STMT_OMP_INTEROP_DIRECTIVE
@ STMT_OMP_INTEROP_DIRECTIVE
Definition: ASTBitCodes.h:1979
clang::OffsetOfNode::Base
@ Base
An implicit indirection through a C++ base class, when the field found is in a base class.
Definition: Expr.h:2361
OpenMPClause.h
clang::serialization::EXPR_CXX_CONST_CAST
@ EXPR_CXX_CONST_CAST
A CXXConstCastExpr record.
Definition: ASTBitCodes.h:1838
clang::AddrLabelExpr
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition: Expr.h:4309
clang::OMPArrayShapingExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: ExprOpenMP.h:196
clang::ParenExpr::setRParen
void setRParen(SourceLocation Loc)
Definition: Expr.h:2149
clang::CXXFunctionalCastExpr
Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr....
Definition: ExprCXX.h:1733
clang::DeclGroupRef
Definition: DeclGroup.h:51
clang::DesignatedInitExpr::Designator
Represents a single C99 designator.
Definition: Expr.h:5109
clang::FloatingLiteral::Create
static FloatingLiteral * Create(const ASTContext &C, const llvm::APFloat &V, bool isexact, QualType Type, SourceLocation L)
Definition: Expr.cpp:1083
clang::CharacterLiteral::setValue
void setValue(unsigned Val)
Definition: Expr.h:1631
clang::serialization::EXPR_NO_INIT
@ EXPR_NO_INIT
An NoInitExpr record.
Definition: ASTBitCodes.h:1683
clang::StmtExpr::setLParenLoc
void setLParenLoc(SourceLocation L)
Definition: Expr.h:4379
clang::ArraySubscriptExpr
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2654
clang::CXXUuidofExpr
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Definition: ExprCXX.h:1063
clang::DependentScopeDeclRefExpr
A qualified reference to a name whose declaration cannot yet be resolved.
Definition: ExprCXX.h:3215
clang::DoStmt
DoStmt - This represents a 'do/while' stmt.
Definition: Stmt.h:2514
clang::CXXNewExpr::setOperatorDelete
void setOperatorDelete(FunctionDecl *D)
Definition: ExprCXX.h:2267
CapturedStmt.h
clang::WhileStmt::CreateEmpty
static WhileStmt * CreateEmpty(const ASTContext &Ctx, bool HasVar)
Create an empty while statement optionally with storage for a condition variable.
Definition: Stmt.cpp:1151
clang::serialization::EXPR_VA_ARG
@ EXPR_VA_ARG
A VAArgExpr record.
Definition: ASTBitCodes.h:1695
clang::AddrLabelExpr::setLabel
void setLabel(LabelDecl *L)
Definition: Expr.h:4333
clang::VAArgExpr::setSubExpr
void setSubExpr(Expr *E)
Definition: Expr.h:4656
clang::ObjCMessageExpr::CreateEmpty
static ObjCMessageExpr * CreateEmpty(const ASTContext &Context, unsigned NumArgs, unsigned NumStoredSelLocs)
Create an empty Objective-C message expression, to be filled in by subsequent calls.
Definition: ExprObjC.cpp:232
clang::ObjCEncodeExpr::setAtLoc
void setAtLoc(SourceLocation L)
Definition: ExprObjC.h:424
StmtVisitor.h
clang::CXXUnresolvedConstructExpr::CreateEmpty
static CXXUnresolvedConstructExpr * CreateEmpty(const ASTContext &Context, unsigned NumArgs)
Definition: ExprCXX.cpp:1356
LLVM.h
clang::OMPMaskedTaskLoopSimdDirective::CreateEmpty
static OMPMaskedTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1319
clang::CXXNullPtrLiteralExpr
The null pointer literal (C++11 [lex.nullptr])
Definition: ExprCXX.h:766
clang::PredefinedExpr::setLocation
void setLocation(SourceLocation L)
Definition: Expr.h:2021
clang::ExtVectorElementExpr::setAccessorLoc
void setAccessorLoc(SourceLocation L)
Definition: Expr.h:5940
clang::CoroutineBodyStmt
Represents the body of a coroutine.
Definition: StmtCXX.h:317
clang::OffsetOfNode::Field
@ Field
A field.
Definition: Expr.h:2356
clang::concepts::ExprRequirement::SatisfactionStatus
SatisfactionStatus
Definition: ExprConcepts.h:256
clang::serialization::STMT_OMP_TASKWAIT_DIRECTIVE
@ STMT_OMP_TASKWAIT_DIRECTIVE
Definition: ASTBitCodes.h:1937
clang::serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE
@ STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1966
clang::Stmt::UnresolvedMemberExprBits
UnresolvedMemberExprBitfields UnresolvedMemberExprBits
Definition: Stmt.h:1071
clang::CoawaitExpr
Represents a 'co_await' expression.
Definition: ExprCXX.h:4823
clang::UnaryOperatorKind
UnaryOperatorKind
Definition: OperationKinds.h:30
clang::BreakStmt
BreakStmt - This represents a break.
Definition: Stmt.h:2759
clang::serialization::EXPR_OBJC_ENCODE
@ EXPR_OBJC_ENCODE
An ObjCEncodeExpr record.
Definition: ASTBitCodes.h:1743
clang::ShuffleVectorExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: Expr.h:4424
clang::serialization::EXPR_OBJC_BRIDGED_CAST
@ EXPR_OBJC_BRIDGED_CAST
Definition: ASTBitCodes.h:1992
clang::concepts::ExprRequirement::SS_ExprSubstitutionFailure
@ SS_ExprSubstitutionFailure
Definition: ExprConcepts.h:258
clang::OverloadExpr
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr.
Definition: ExprCXX.h:2904
clang::OMPTargetTeamsDistributeSimdDirective::CreateEmpty
static OMPTargetTeamsDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:2252
clang::serialization::EXPR_OBJC_IVAR_REF_EXPR
@ EXPR_OBJC_IVAR_REF_EXPR
An ObjCIvarRefExpr record.
Definition: ASTBitCodes.h:1752
clang::serialization::STMT_STOP
@ STMT_STOP
A marker record that indicates that we are at the end of an expression.
Definition: ASTBitCodes.h:1533
clang::OMPCancellationPointDirective
This represents '#pragma omp cancellation point' directive.
Definition: StmtOpenMP.h:3541
clang::OMPDispatchDirective
This represents '#pragma omp dispatch' directive.
Definition: StmtOpenMP.h:5754
clang::CXXDependentScopeMemberExpr
Represents a C++ member access expression where the actual member referenced could not be resolved be...
Definition: ExprCXX.h:3574
clang::OMPSectionsDirective::CreateEmpty
static OMPSectionsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:506
clang::serialization::STMT_OMP_SINGLE_DIRECTIVE
@ STMT_OMP_SINGLE_DIRECTIVE
Definition: ASTBitCodes.h:1925
clang::serialization::EXPR_OBJC_KVC_REF_EXPR
@ EXPR_OBJC_KVC_REF_EXPR
UNUSED.
Definition: ASTBitCodes.h:1761
clang::ObjCIvarRefExpr::setIsFreeIvar
void setIsFreeIvar(bool A)
Definition: ExprObjC.h:587
clang::RecoveryExpr::CreateEmpty
static RecoveryExpr * CreateEmpty(ASTContext &Ctx, unsigned NumSubExprs)
Definition: Expr.cpp:4931
clang::OMPTeamsDistributeDirective::CreateEmpty
static OMPTeamsDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1856
clang::OMPTaskLoopSimdDirective::CreateEmpty
static OMPTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1142
clang::ASTStmtReader::ASTStmtReader
ASTStmtReader(ASTRecordReader &Record, llvm::BitstreamCursor &Cursor)
Definition: ASTReaderStmt.cpp:101
clang::CompoundAssignOperator
CompoundAssignOperator - For compound assignments (e.g.
Definition: Expr.h:4059
clang::BinaryOperatorKind
BinaryOperatorKind
Definition: OperationKinds.h:25
clang::serialization::EXPR_PAREN
@ EXPR_PAREN
A ParenExpr record.
Definition: ASTBitCodes.h:1626
clang::serialization::EXPR_CXX_DEFAULT_INIT
@ EXPR_CXX_DEFAULT_INIT
Definition: ASTBitCodes.h:1864
clang::OMPParallelGenericLoopDirective::CreateEmpty
static OMPParallelGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:2478
clang::ExprValueKind
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:120
clang::CXXNoexceptExpr
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
Definition: ExprCXX.h:4021
clang::serialization::STMT_SEH_EXCEPT
@ STMT_SEH_EXCEPT
Definition: ASTBitCodes.h:1910
clang::Expr::isValueDependent
bool isValueDependent() const
Determines whether the value of this expression depends on.
Definition: Expr.h:168
clang::CXXUnresolvedConstructExpr
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
Definition: ExprCXX.h:3452
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:85
clang::DeclRefExpr::setLocation
void setLocation(SourceLocation L)
Definition: Expr.h:1313
clang::serialization::STMT_GCCASM
@ STMT_GCCASM
A GCC-style AsmStmt record.
Definition: ASTBitCodes.h:1596
clang::OMPSectionDirective::setHasCancel
void setHasCancel(bool Has)
Set cancel state.
Definition: StmtOpenMP.h:1906
clang::ASTRecordReader::readExpr
Expr * readExpr()
Reads an expression.
Definition: ASTRecordReader.h:134
clang::OMPInteropDirective::CreateEmpty
static OMPInteropDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:2271
clang::OMPExecutableDirective
This is a basic class for representing single OpenMP executable directive.
Definition: StmtOpenMP.h:266
clang::serialization::STMT_OMP_TARGET_UPDATE_DIRECTIVE
@ STMT_OMP_TARGET_UPDATE_DIRECTIVE
Definition: ASTBitCodes.h:1964
clang::serialization::EXPR_CUDA_KERNEL_CALL
@ EXPR_CUDA_KERNEL_CALL
Definition: ASTBitCodes.h:1899
clang::StringLiteral::getCharByteWidth
unsigned getCharByteWidth() const
Definition: Expr.h:1889
clang::OMPTargetDirective::CreateEmpty
static OMPTargetDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:932
clang::OMPArraySectionExpr::setColonLocSecond
void setColonLocSecond(SourceLocation L)
Definition: ExprOpenMP.h:122
clang::serialization::STMT_OMP_PARALLEL_MASTER_DIRECTIVE
@ STMT_OMP_PARALLEL_MASTER_DIRECTIVE
Definition: ASTBitCodes.h:1930
clang::Stmt::CXXDeleteExprBits
CXXDeleteExprBitfields CXXDeleteExprBits
Definition: Stmt.h:1062
clang::CXXForRangeStmt
CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...
Definition: StmtCXX.h:134
Lambda.h
clang::Stmt::DeclRefExprBits
DeclRefExprBitfields DeclRefExprBits
Definition: Stmt.h:1031
clang::ObjCIsaExpr::setIsaMemberLoc
void setIsaMemberLoc(SourceLocation L)
Definition: ExprObjC.h:1515
clang::DesignatedInitExpr::CreateEmpty
static DesignatedInitExpr * CreateEmpty(const ASTContext &C, unsigned NumIndexExprs)
Definition: Expr.cpp:4444
clang::serialization::COK_CompoundLiteral
@ COK_CompoundLiteral
Definition: ASTBitCodes.h:2036
clang::OMPParallelMasterTaskLoopDirective::CreateEmpty
static OMPParallelMasterTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1364
clang::ObjCPropertyAttribute::Kind
Kind
Definition: DeclObjCCommon.h:22
clang::DeclStmt
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
Definition: Stmt.h:1303
clang::ContinueStmt
ContinueStmt - This represents a continue.
Definition: Stmt.h:2729
clang::ChooseExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: Expr.h:4580
clang::OffsetOfNode::Identifier
@ Identifier
A field in a dependent type, known only by its name.
Definition: Expr.h:2358
clang::Expr::setDependence
void setDependence(ExprDependence Deps)
Each concrete expr subclass is expected to compute its dependence and call this in the constructor.
Definition: Expr.h:134
clang::CallExpr::setStoredFPFeatures
void setStoredFPFeatures(FPOptionsOverride F)
Set FPOptionsOverride in trailing storage. Used only by Serialization.
Definition: Expr.h:3079
clang::ConstantExpr::CreateEmpty
static ConstantExpr * CreateEmpty(const ASTContext &Context, ResultStorageKind StorageKind)
Definition: Expr.cpp:418
clang::OMPTeamsDistributeSimdDirective::CreateEmpty
static OMPTeamsDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1899
clang::serialization::STMT_OMP_MASTER_TASKLOOP_DIRECTIVE
@ STMT_OMP_MASTER_TASKLOOP_DIRECTIVE
Definition: ASTBitCodes.h:1955
clang::ObjCSelectorExpr::setAtLoc
void setAtLoc(SourceLocation L)
Definition: ExprObjC.h:473
clang::OMPUnrollDirective::CreateEmpty
static OMPUnrollDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses)
Build an empty '#pragma omp unroll' AST node for deserialization.
Definition: StmtOpenMP.cpp:443
clang::CXXConstCastExpr
A C++ const_cast expression (C++ [expr.const.cast]).
Definition: ExprCXX.h:562
clang::OMPSimdDirective::CreateEmpty
static OMPSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:327
clang::CXXThisExpr
Represents the this expression in C++.
Definition: ExprCXX.h:1149
clang::serialization::EXPR_COYIELD
@ EXPR_COYIELD
Definition: ASTBitCodes.h:1999
clang::ExtVectorElementExpr
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
Definition: Expr.h:5915
clang::OMPTeamsDistributeParallelForDirective
This represents '#pragma omp teams distribute parallel for' composite directive.
Definition: StmtOpenMP.h:5050
DeclarationName.h
clang::IfStatementKind
IfStatementKind
In an if statement, this denotes whether the statement is a constexpr or consteval if statement.
Definition: Specifiers.h:36
clang::ObjCSubscriptRefExpr::setBaseExpr
void setBaseExpr(Stmt *S)
Definition: ExprObjC.h:881
clang::TypoExpr
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
Definition: Expr.h:6372
clang::PredefinedExpr
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1968
clang::serialization::EXPR_PREDEFINED
@ EXPR_PREDEFINED
A PredefinedExpr record.
Definition: ASTBitCodes.h:1605
clang::serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT
@ EXPR_CXX_UNRESOLVED_CONSTRUCT
Definition: ASTBitCodes.h:1876
clang::MSDependentExistsStmt
Representation of a Microsoft __if_exists or __if_not_exists statement with a dependent name.
Definition: StmtCXX.h:252
clang::serialization::STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE
@ STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE
Definition: ASTBitCodes.h:1957
clang::FPOptionsOverride::getFromOpaqueInt
static FPOptionsOverride getFromOpaqueInt(storage_type I)
Definition: LangOptions.h:863
clang::serialization::EXPR_ARRAY_TYPE_TRAIT
@ EXPR_ARRAY_TYPE_TRAIT
Definition: ASTBitCodes.h:1886
clang::OMPOrderedDirective::CreateEmpty
static OMPOrderedDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, bool IsStandalone, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:889
clang::SizeOfPackExpr::isPartiallySubstituted
bool isPartiallySubstituted() const
Determine whether this represents a partially-substituted sizeof...
Definition: ExprCXX.h:4239
clang::SEHFinallyStmt
Definition: Stmt.h:3409
clang::CUDAKernelCallExpr
Represents a call to a CUDA kernel function.
Definition: ExprCXX.h:232
clang::serialization::EXPR_CXX_INHERITED_CTOR_INIT
@ EXPR_CXX_INHERITED_CTOR_INIT
A CXXInheritedCtorInitExpr record.
Definition: ASTBitCodes.h:1823
clang::ExtVectorElementExpr::setBase
void setBase(Expr *E)
Definition: Expr.h:5934
clang::ObjCMessageExpr::Instance
@ Instance
The receiver is an object instance.
Definition: ExprObjC.h:1091
clang::ObjCSelectorExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: ExprObjC.h:474
clang::serialization::EXPR_MATERIALIZE_TEMPORARY
@ EXPR_MATERIALIZE_TEMPORARY
Definition: ASTBitCodes.h:1893
clang::ConstantExpr::ResultStorageKind
ResultStorageKind
Describes the kind of result that can be tail-allocated.
Definition: Expr.h:1053
clang::serialization::EXPR_RECOVERY
@ EXPR_RECOVERY
A RecoveryExpr record.
Definition: ASTBitCodes.h:1731
clang::OMPArrayShapingExpr::setLParenLoc
void setLParenLoc(SourceLocation L)
Definition: ExprOpenMP.h:193
clang::OMPSimdDirective
This represents '#pragma omp simd' directive.
Definition: StmtOpenMP.h:1569
clang::UnaryExprOrTypeTraitExpr::setOperatorLoc
void setOperatorLoc(SourceLocation L)
Definition: Expr.h:2632
clang::CodeGen::CleanupKind
CleanupKind
Definition: EHScopeStack.h:77
clang::OMPMaskedTaskLoopDirective::CreateEmpty
static OMPMaskedTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1231
clang::Expr::setType
void setType(QualType t)
Definition: Expr.h:142
clang::OMPArraySectionExpr
OpenMP 5.0 [2.1.5, Array Sections].
Definition: ExprOpenMP.h:56
clang
Definition: CalledOnceCheck.h:17
clang::TemplateArgumentListInfo::setRAngleLoc
void setRAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:583
clang::CompoundAssignOperator::setComputationResultType
void setComputationResultType(QualType T)
Definition: Expr.h:4097
clang::serialization::STMT_OMP_SECTIONS_DIRECTIVE
@ STMT_OMP_SECTIONS_DIRECTIVE
Definition: ASTBitCodes.h:1923
clang::serialization::EXPR_CXX_UUIDOF_EXPR
@ EXPR_CXX_UUIDOF_EXPR
Definition: ASTBitCodes.h:1907
clang::IntegerLiteral::setLocation
void setLocation(SourceLocation Location)
Definition: Expr.h:1531
clang::InitListExpr::setSyntacticForm
void setSyntacticForm(InitListExpr *Init)
Definition: Expr.h:4961
clang::ASTRecordReader::readSourceLocation
SourceLocation readSourceLocation(LocSeq *Seq=nullptr)
Read a source location, advancing Idx.
Definition: ASTRecordReader.h:275
clang::CXXFunctionalCastExpr::CreateEmpty
static CXXFunctionalCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize, bool HasFPFeatures)
Definition: ExprCXX.cpp:858
clang::serialization::EXPR_COMPOUND_ASSIGN_OPERATOR
@ EXPR_COMPOUND_ASSIGN_OPERATOR
A CompoundAssignOperator record.
Definition: ASTBitCodes.h:1656
clang::OMPTargetTeamsDirective
This represents '#pragma omp target teams' directive.
Definition: StmtOpenMP.h:5143
clang::serialization::EXPR_EXT_VECTOR_ELEMENT
@ EXPR_EXT_VECTOR_ELEMENT
An ExtVectorElementExpr record.
Definition: ASTBitCodes.h:1671
distance
float __ovld __cnfn distance(float, float)
Returns the distance between p0 and p1.
clang::ObjCDictionaryLiteral::CreateEmpty
static ObjCDictionaryLiteral * CreateEmpty(const ASTContext &C, unsigned NumElements, bool HasPackExpansions)
Definition: ExprObjC.cpp:88
clang::CXXDynamicCastExpr::CreateEmpty
static CXXDynamicCastExpr * CreateEmpty(const ASTContext &Context, unsigned pathSize)
Definition: ExprCXX.cpp:753
UnresolvedSet.h
clang::UnresolvedSetImpl::addDecl
void addDecl(NamedDecl *D)
Definition: UnresolvedSet.h:91
clang::ConstraintSatisfaction::ContainsErrors
bool ContainsErrors
Definition: ASTConcept.h:47
clang::OMPTargetTeamsGenericLoopDirective::CreateEmpty
static OMPTargetTeamsGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:2434
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:71
clang::ObjCEncodeExpr::setEncodedTypeSourceInfo
void setEncodedTypeSourceInfo(TypeSourceInfo *EncType)
Definition: ExprObjC.h:432
clang::OMPDistributeParallelForDirective
This represents '#pragma omp distribute parallel for' composite directive.
Definition: StmtOpenMP.h:4491
clang::OMPGenericLoopDirective::CreateEmpty
static OMPGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with a place for NumClauses clauses.
Definition: StmtOpenMP.cpp:2347
clang::DefaultStmt
Definition: Stmt.h:1759
clang::OMPParallelMaskedDirective
This represents '#pragma omp parallel masked' directive.
Definition: StmtOpenMP.h:2319
clang::ObjCAutoreleasePoolStmt
Represents Objective-C's @autoreleasepool Statement.
Definition: StmtObjC.h:393
clang::BinaryOperator::CreateEmpty
static BinaryOperator * CreateEmpty(const ASTContext &C, bool hasFPFeatures)
Definition: Expr.cpp:4618
clang::CXXNewExpr::isParenTypeId
bool isParenTypeId() const
Definition: ExprCXX.h:2316
clang::CXXCatchStmt
CXXCatchStmt - This represents a C++ catch block.
Definition: StmtCXX.h:28
clang::serialization::STMT_OMP_BARRIER_DIRECTIVE
@ STMT_OMP_BARRIER_DIRECTIVE
Definition: ASTBitCodes.h:1936
clang::ASTStmtReader::ReadTemplateKWAndArgsInfo
void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args, TemplateArgumentLoc *ArgsLocArray, unsigned NumTemplateArgs)
Read and initialize a ExplicitTemplateArgumentList