clang  14.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 =
111  NumStmtFields + llvm::BitWidth<ExprDependence> + 3;
112 
113  /// Read and initialize a ExplicitTemplateArgumentList structure.
114  void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
115  TemplateArgumentLoc *ArgsLocArray,
116  unsigned NumTemplateArgs);
117 
118  /// Read and initialize a ExplicitTemplateArgumentList structure.
119  void ReadExplicitTemplateArgumentList(ASTTemplateArgumentListInfo &ArgList,
120  unsigned NumTemplateArgs);
121 
122  void VisitStmt(Stmt *S);
123 #define STMT(Type, Base) \
124  void Visit##Type(Type *);
125 #include "clang/AST/StmtNodes.inc"
126  };
127 
128 } // namespace clang
129 
131  TemplateArgumentLoc *ArgsLocArray,
132  unsigned NumTemplateArgs) {
133  SourceLocation TemplateKWLoc = readSourceLocation();
134  TemplateArgumentListInfo ArgInfo;
135  ArgInfo.setLAngleLoc(readSourceLocation());
136  ArgInfo.setRAngleLoc(readSourceLocation());
137  for (unsigned i = 0; i != NumTemplateArgs; ++i)
138  ArgInfo.addArgument(Record.readTemplateArgumentLoc());
139  Args.initializeFrom(TemplateKWLoc, ArgInfo, ArgsLocArray);
140 }
141 
143  assert(Record.getIdx() == NumStmtFields && "Incorrect statement field count");
144 }
145 
146 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
147  VisitStmt(S);
148  S->setSemiLoc(readSourceLocation());
149  S->NullStmtBits.HasLeadingEmptyMacro = Record.readInt();
150 }
151 
152 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
153  VisitStmt(S);
155  unsigned NumStmts = Record.readInt();
156  while (NumStmts--)
157  Stmts.push_back(Record.readSubStmt());
158  S->setStmts(Stmts);
159  S->CompoundStmtBits.LBraceLoc = readSourceLocation();
160  S->RBraceLoc = readSourceLocation();
161 }
162 
163 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
164  VisitStmt(S);
165  Record.recordSwitchCaseID(S, Record.readInt());
166  S->setKeywordLoc(readSourceLocation());
167  S->setColonLoc(readSourceLocation());
168 }
169 
170 void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
171  VisitSwitchCase(S);
172  bool CaseStmtIsGNURange = Record.readInt();
173  S->setLHS(Record.readSubExpr());
174  S->setSubStmt(Record.readSubStmt());
175  if (CaseStmtIsGNURange) {
176  S->setRHS(Record.readSubExpr());
177  S->setEllipsisLoc(readSourceLocation());
178  }
179 }
180 
181 void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
182  VisitSwitchCase(S);
183  S->setSubStmt(Record.readSubStmt());
184 }
185 
186 void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
187  VisitStmt(S);
188  bool IsSideEntry = Record.readInt();
189  auto *LD = readDeclAs<LabelDecl>();
190  LD->setStmt(S);
191  S->setDecl(LD);
192  S->setSubStmt(Record.readSubStmt());
193  S->setIdentLoc(readSourceLocation());
194  S->setSideEntry(IsSideEntry);
195 }
196 
197 void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) {
198  VisitStmt(S);
199  // NumAttrs in AttributedStmt is set when creating an empty
200  // AttributedStmt in AttributedStmt::CreateEmpty, since it is needed
201  // to allocate the right amount of space for the trailing Attr *.
202  uint64_t NumAttrs = Record.readInt();
203  AttrVec Attrs;
204  Record.readAttributes(Attrs);
205  (void)NumAttrs;
206  assert(NumAttrs == S->AttributedStmtBits.NumAttrs);
207  assert(NumAttrs == Attrs.size());
208  std::copy(Attrs.begin(), Attrs.end(), S->getAttrArrayPtr());
209  S->SubStmt = Record.readSubStmt();
210  S->AttributedStmtBits.AttrLoc = readSourceLocation();
211 }
212 
213 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
214  VisitStmt(S);
215 
216  bool HasElse = Record.readInt();
217  bool HasVar = Record.readInt();
218  bool HasInit = Record.readInt();
219 
220  S->setStatementKind(static_cast<IfStatementKind>(Record.readInt()));
221  S->setCond(Record.readSubExpr());
222  S->setThen(Record.readSubStmt());
223  if (HasElse)
224  S->setElse(Record.readSubStmt());
225  if (HasVar)
226  S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
227  if (HasInit)
228  S->setInit(Record.readSubStmt());
229 
230  S->setIfLoc(readSourceLocation());
231  S->setLParenLoc(readSourceLocation());
232  S->setRParenLoc(readSourceLocation());
233  if (HasElse)
234  S->setElseLoc(readSourceLocation());
235 }
236 
237 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
238  VisitStmt(S);
239 
240  bool HasInit = Record.readInt();
241  bool HasVar = Record.readInt();
242  bool AllEnumCasesCovered = Record.readInt();
243  if (AllEnumCasesCovered)
244  S->setAllEnumCasesCovered();
245 
246  S->setCond(Record.readSubExpr());
247  S->setBody(Record.readSubStmt());
248  if (HasInit)
249  S->setInit(Record.readSubStmt());
250  if (HasVar)
251  S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
252 
253  S->setSwitchLoc(readSourceLocation());
254  S->setLParenLoc(readSourceLocation());
255  S->setRParenLoc(readSourceLocation());
256 
257  SwitchCase *PrevSC = nullptr;
258  for (auto E = Record.size(); Record.getIdx() != E; ) {
259  SwitchCase *SC = Record.getSwitchCaseWithID(Record.readInt());
260  if (PrevSC)
261  PrevSC->setNextSwitchCase(SC);
262  else
263  S->setSwitchCaseList(SC);
264 
265  PrevSC = SC;
266  }
267 }
268 
269 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
270  VisitStmt(S);
271 
272  bool HasVar = Record.readInt();
273 
274  S->setCond(Record.readSubExpr());
275  S->setBody(Record.readSubStmt());
276  if (HasVar)
277  S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
278 
279  S->setWhileLoc(readSourceLocation());
280  S->setLParenLoc(readSourceLocation());
281  S->setRParenLoc(readSourceLocation());
282 }
283 
284 void ASTStmtReader::VisitDoStmt(DoStmt *S) {
285  VisitStmt(S);
286  S->setCond(Record.readSubExpr());
287  S->setBody(Record.readSubStmt());
288  S->setDoLoc(readSourceLocation());
289  S->setWhileLoc(readSourceLocation());
290  S->setRParenLoc(readSourceLocation());
291 }
292 
293 void ASTStmtReader::VisitForStmt(ForStmt *S) {
294  VisitStmt(S);
295  S->setInit(Record.readSubStmt());
296  S->setCond(Record.readSubExpr());
297  S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
298  S->setInc(Record.readSubExpr());
299  S->setBody(Record.readSubStmt());
300  S->setForLoc(readSourceLocation());
301  S->setLParenLoc(readSourceLocation());
302  S->setRParenLoc(readSourceLocation());
303 }
304 
305 void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
306  VisitStmt(S);
307  S->setLabel(readDeclAs<LabelDecl>());
308  S->setGotoLoc(readSourceLocation());
309  S->setLabelLoc(readSourceLocation());
310 }
311 
312 void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
313  VisitStmt(S);
314  S->setGotoLoc(readSourceLocation());
315  S->setStarLoc(readSourceLocation());
316  S->setTarget(Record.readSubExpr());
317 }
318 
319 void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
320  VisitStmt(S);
321  S->setContinueLoc(readSourceLocation());
322 }
323 
324 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
325  VisitStmt(S);
326  S->setBreakLoc(readSourceLocation());
327 }
328 
329 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
330  VisitStmt(S);
331 
332  bool HasNRVOCandidate = Record.readInt();
333 
334  S->setRetValue(Record.readSubExpr());
335  if (HasNRVOCandidate)
336  S->setNRVOCandidate(readDeclAs<VarDecl>());
337 
338  S->setReturnLoc(readSourceLocation());
339 }
340 
341 void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
342  VisitStmt(S);
343  S->setStartLoc(readSourceLocation());
344  S->setEndLoc(readSourceLocation());
345 
346  if (Record.size() - Record.getIdx() == 1) {
347  // Single declaration
348  S->setDeclGroup(DeclGroupRef(readDecl()));
349  } else {
351  int N = Record.size() - Record.getIdx();
352  Decls.reserve(N);
353  for (int I = 0; I < N; ++I)
354  Decls.push_back(readDecl());
355  S->setDeclGroup(DeclGroupRef(DeclGroup::Create(Record.getContext(),
356  Decls.data(),
357  Decls.size())));
358  }
359 }
360 
361 void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
362  VisitStmt(S);
363  S->NumOutputs = Record.readInt();
364  S->NumInputs = Record.readInt();
365  S->NumClobbers = Record.readInt();
366  S->setAsmLoc(readSourceLocation());
367  S->setVolatile(Record.readInt());
368  S->setSimple(Record.readInt());
369 }
370 
371 void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) {
372  VisitAsmStmt(S);
373  S->NumLabels = Record.readInt();
374  S->setRParenLoc(readSourceLocation());
375  S->setAsmString(cast_or_null<StringLiteral>(Record.readSubStmt()));
376 
377  unsigned NumOutputs = S->getNumOutputs();
378  unsigned NumInputs = S->getNumInputs();
379  unsigned NumClobbers = S->getNumClobbers();
380  unsigned NumLabels = S->getNumLabels();
381 
382  // Outputs and inputs
386  for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
387  Names.push_back(Record.readIdentifier());
388  Constraints.push_back(cast_or_null<StringLiteral>(Record.readSubStmt()));
389  Exprs.push_back(Record.readSubStmt());
390  }
391 
392  // Constraints
394  for (unsigned I = 0; I != NumClobbers; ++I)
395  Clobbers.push_back(cast_or_null<StringLiteral>(Record.readSubStmt()));
396 
397  // Labels
398  for (unsigned I = 0, N = NumLabels; I != N; ++I)
399  Exprs.push_back(Record.readSubStmt());
400 
401  S->setOutputsAndInputsAndClobbers(Record.getContext(),
402  Names.data(), Constraints.data(),
403  Exprs.data(), NumOutputs, NumInputs,
404  NumLabels,
405  Clobbers.data(), NumClobbers);
406 }
407 
408 void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) {
409  VisitAsmStmt(S);
410  S->LBraceLoc = readSourceLocation();
411  S->EndLoc = readSourceLocation();
412  S->NumAsmToks = Record.readInt();
413  std::string AsmStr = readString();
414 
415  // Read the tokens.
416  SmallVector<Token, 16> AsmToks;
417  AsmToks.reserve(S->NumAsmToks);
418  for (unsigned i = 0, e = S->NumAsmToks; i != e; ++i) {
419  AsmToks.push_back(Record.readToken());
420  }
421 
422  // The calls to reserve() for the FooData vectors are mandatory to
423  // prevent dead StringRefs in the Foo vectors.
424 
425  // Read the clobbers.
426  SmallVector<std::string, 16> ClobbersData;
428  ClobbersData.reserve(S->NumClobbers);
429  Clobbers.reserve(S->NumClobbers);
430  for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) {
431  ClobbersData.push_back(readString());
432  Clobbers.push_back(ClobbersData.back());
433  }
434 
435  // Read the operands.
436  unsigned NumOperands = S->NumOutputs + S->NumInputs;
438  SmallVector<std::string, 16> ConstraintsData;
439  SmallVector<StringRef, 16> Constraints;
440  Exprs.reserve(NumOperands);
441  ConstraintsData.reserve(NumOperands);
442  Constraints.reserve(NumOperands);
443  for (unsigned i = 0; i != NumOperands; ++i) {
444  Exprs.push_back(cast<Expr>(Record.readSubStmt()));
445  ConstraintsData.push_back(readString());
446  Constraints.push_back(ConstraintsData.back());
447  }
448 
449  S->initialize(Record.getContext(), AsmStr, AsmToks,
450  Constraints, Exprs, Clobbers);
451 }
452 
453 void ASTStmtReader::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
454  VisitStmt(S);
455  assert(Record.peekInt() == S->NumParams);
456  Record.skipInts(1);
457  auto *StoredStmts = S->getStoredStmts();
458  for (unsigned i = 0;
459  i < CoroutineBodyStmt::SubStmt::FirstParamMove + S->NumParams; ++i)
460  StoredStmts[i] = Record.readSubStmt();
461 }
462 
463 void ASTStmtReader::VisitCoreturnStmt(CoreturnStmt *S) {
464  VisitStmt(S);
465  S->CoreturnLoc = Record.readSourceLocation();
466  for (auto &SubStmt: S->SubStmts)
467  SubStmt = Record.readSubStmt();
468  S->IsImplicit = Record.readInt() != 0;
469 }
470 
471 void ASTStmtReader::VisitCoawaitExpr(CoawaitExpr *E) {
472  VisitExpr(E);
473  E->KeywordLoc = readSourceLocation();
474  for (auto &SubExpr: E->SubExprs)
475  SubExpr = Record.readSubStmt();
476  E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt());
477  E->setIsImplicit(Record.readInt() != 0);
478 }
479 
480 void ASTStmtReader::VisitCoyieldExpr(CoyieldExpr *E) {
481  VisitExpr(E);
482  E->KeywordLoc = readSourceLocation();
483  for (auto &SubExpr: E->SubExprs)
484  SubExpr = Record.readSubStmt();
485  E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt());
486 }
487 
488 void ASTStmtReader::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) {
489  VisitExpr(E);
490  E->KeywordLoc = readSourceLocation();
491  for (auto &SubExpr: E->SubExprs)
492  SubExpr = Record.readSubStmt();
493 }
494 
495 void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) {
496  VisitStmt(S);
497  Record.skipInts(1);
498  S->setCapturedDecl(readDeclAs<CapturedDecl>());
499  S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record.readInt()));
500  S->setCapturedRecordDecl(readDeclAs<RecordDecl>());
501 
502  // Capture inits
503  for (CapturedStmt::capture_init_iterator I = S->capture_init_begin(),
504  E = S->capture_init_end();
505  I != E; ++I)
506  *I = Record.readSubExpr();
507 
508  // Body
509  S->setCapturedStmt(Record.readSubStmt());
510  S->getCapturedDecl()->setBody(S->getCapturedStmt());
511 
512  // Captures
513  for (auto &I : S->captures()) {
514  I.VarAndKind.setPointer(readDeclAs<VarDecl>());
515  I.VarAndKind.setInt(
516  static_cast<CapturedStmt::VariableCaptureKind>(Record.readInt()));
517  I.Loc = readSourceLocation();
518  }
519 }
520 
521 void ASTStmtReader::VisitExpr(Expr *E) {
522  VisitStmt(E);
523  E->setType(Record.readType());
524 
525  // FIXME: write and read all DependentFlags with a single call.
526  bool TypeDependent = Record.readInt();
527  bool ValueDependent = Record.readInt();
528  bool InstantiationDependent = Record.readInt();
529  bool ContainsUnexpandedTemplateParameters = Record.readInt();
530  bool ContainsErrors = Record.readInt();
531  auto Deps = ExprDependence::None;
532  if (TypeDependent)
533  Deps |= ExprDependence::Type;
534  if (ValueDependent)
535  Deps |= ExprDependence::Value;
536  if (InstantiationDependent)
537  Deps |= ExprDependence::Instantiation;
538  if (ContainsUnexpandedTemplateParameters)
539  Deps |= ExprDependence::UnexpandedPack;
540  if (ContainsErrors)
541  Deps |= ExprDependence::Error;
542  E->setDependence(Deps);
543 
544  E->setValueKind(static_cast<ExprValueKind>(Record.readInt()));
545  E->setObjectKind(static_cast<ExprObjectKind>(Record.readInt()));
546  assert(Record.getIdx() == NumExprFields &&
547  "Incorrect expression field count");
548 }
549 
550 void ASTStmtReader::VisitConstantExpr(ConstantExpr *E) {
551  VisitExpr(E);
552 
553  auto StorageKind = Record.readInt();
554  assert(E->ConstantExprBits.ResultKind == StorageKind && "Wrong ResultKind!");
555 
556  E->ConstantExprBits.APValueKind = Record.readInt();
557  E->ConstantExprBits.IsUnsigned = Record.readInt();
558  E->ConstantExprBits.BitWidth = Record.readInt();
559  E->ConstantExprBits.HasCleanup = false; // Not serialized, see below.
560  E->ConstantExprBits.IsImmediateInvocation = Record.readInt();
561 
562  switch (StorageKind) {
564  break;
565 
567  E->Int64Result() = Record.readInt();
568  break;
569 
571  E->APValueResult() = Record.readAPValue();
572  if (E->APValueResult().needsCleanup()) {
573  E->ConstantExprBits.HasCleanup = true;
574  Record.getContext().addDestruction(&E->APValueResult());
575  }
576  break;
577  default:
578  llvm_unreachable("unexpected ResultKind!");
579  }
580 
581  E->setSubExpr(Record.readSubExpr());
582 }
583 
584 void ASTStmtReader::VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E) {
585  VisitExpr(E);
586 
587  E->setLocation(readSourceLocation());
588  E->setLParenLocation(readSourceLocation());
589  E->setRParenLocation(readSourceLocation());
590 
591  E->setTypeSourceInfo(Record.readTypeSourceInfo());
592 }
593 
594 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
595  VisitExpr(E);
596  bool HasFunctionName = Record.readInt();
597  E->PredefinedExprBits.HasFunctionName = HasFunctionName;
598  E->PredefinedExprBits.Kind = Record.readInt();
599  E->setLocation(readSourceLocation());
600  if (HasFunctionName)
601  E->setFunctionName(cast<StringLiteral>(Record.readSubExpr()));
602 }
603 
604 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
605  VisitExpr(E);
606 
607  E->DeclRefExprBits.HasQualifier = Record.readInt();
608  E->DeclRefExprBits.HasFoundDecl = Record.readInt();
609  E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record.readInt();
610  E->DeclRefExprBits.HadMultipleCandidates = Record.readInt();
611  E->DeclRefExprBits.RefersToEnclosingVariableOrCapture = Record.readInt();
612  E->DeclRefExprBits.NonOdrUseReason = Record.readInt();
613  unsigned NumTemplateArgs = 0;
614  if (E->hasTemplateKWAndArgsInfo())
615  NumTemplateArgs = Record.readInt();
616 
617  if (E->hasQualifier())
618  new (E->getTrailingObjects<NestedNameSpecifierLoc>())
619  NestedNameSpecifierLoc(Record.readNestedNameSpecifierLoc());
620 
621  if (E->hasFoundDecl())
622  *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>();
623 
624  if (E->hasTemplateKWAndArgsInfo())
625  ReadTemplateKWAndArgsInfo(
626  *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
627  E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
628 
629  E->D = readDeclAs<ValueDecl>();
630  E->setLocation(readSourceLocation());
631  E->DNLoc = Record.readDeclarationNameLoc(E->getDecl()->getDeclName());
632 }
633 
634 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
635  VisitExpr(E);
636  E->setLocation(readSourceLocation());
637  E->setValue(Record.getContext(), Record.readAPInt());
638 }
639 
640 void ASTStmtReader::VisitFixedPointLiteral(FixedPointLiteral *E) {
641  VisitExpr(E);
642  E->setLocation(readSourceLocation());
643  E->setScale(Record.readInt());
644  E->setValue(Record.getContext(), Record.readAPInt());
645 }
646 
647 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
648  VisitExpr(E);
649  E->setRawSemantics(
650  static_cast<llvm::APFloatBase::Semantics>(Record.readInt()));
651  E->setExact(Record.readInt());
652  E->setValue(Record.getContext(), Record.readAPFloat(E->getSemantics()));
653  E->setLocation(readSourceLocation());
654 }
655 
656 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
657  VisitExpr(E);
658  E->setSubExpr(Record.readSubExpr());
659 }
660 
661 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
662  VisitExpr(E);
663 
664  // NumConcatenated, Length and CharByteWidth are set by the empty
665  // ctor since they are needed to allocate storage for the trailing objects.
666  unsigned NumConcatenated = Record.readInt();
667  unsigned Length = Record.readInt();
668  unsigned CharByteWidth = Record.readInt();
669  assert((NumConcatenated == E->getNumConcatenated()) &&
670  "Wrong number of concatenated tokens!");
671  assert((Length == E->getLength()) && "Wrong Length!");
672  assert((CharByteWidth == E->getCharByteWidth()) && "Wrong character width!");
673  E->StringLiteralBits.Kind = Record.readInt();
674  E->StringLiteralBits.IsPascal = Record.readInt();
675 
676  // The character width is originally computed via mapCharByteWidth.
677  // Check that the deserialized character width is consistant with the result
678  // of calling mapCharByteWidth.
679  assert((CharByteWidth ==
680  StringLiteral::mapCharByteWidth(Record.getContext().getTargetInfo(),
681  E->getKind())) &&
682  "Wrong character width!");
683 
684  // Deserialize the trailing array of SourceLocation.
685  for (unsigned I = 0; I < NumConcatenated; ++I)
686  E->setStrTokenLoc(I, readSourceLocation());
687 
688  // Deserialize the trailing array of char holding the string data.
689  char *StrData = E->getStrDataAsChar();
690  for (unsigned I = 0; I < Length * CharByteWidth; ++I)
691  StrData[I] = Record.readInt();
692 }
693 
694 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
695  VisitExpr(E);
696  E->setValue(Record.readInt());
697  E->setLocation(readSourceLocation());
698  E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record.readInt()));
699 }
700 
701 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
702  VisitExpr(E);
703  E->setLParen(readSourceLocation());
704  E->setRParen(readSourceLocation());
705  E->setSubExpr(Record.readSubExpr());
706 }
707 
708 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
709  VisitExpr(E);
710  unsigned NumExprs = Record.readInt();
711  assert((NumExprs == E->getNumExprs()) && "Wrong NumExprs!");
712  for (unsigned I = 0; I != NumExprs; ++I)
713  E->getTrailingObjects<Stmt *>()[I] = Record.readSubStmt();
714  E->LParenLoc = readSourceLocation();
715  E->RParenLoc = readSourceLocation();
716 }
717 
718 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
719  VisitExpr(E);
720  bool hasFP_Features = Record.readInt();
721  assert(hasFP_Features == E->hasStoredFPFeatures());
722  E->setSubExpr(Record.readSubExpr());
723  E->setOpcode((UnaryOperator::Opcode)Record.readInt());
724  E->setOperatorLoc(readSourceLocation());
725  E->setCanOverflow(Record.readInt());
726  if (hasFP_Features)
728  FPOptionsOverride::getFromOpaqueInt(Record.readInt()));
729 }
730 
731 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
732  VisitExpr(E);
733  assert(E->getNumComponents() == Record.peekInt());
734  Record.skipInts(1);
735  assert(E->getNumExpressions() == Record.peekInt());
736  Record.skipInts(1);
737  E->setOperatorLoc(readSourceLocation());
738  E->setRParenLoc(readSourceLocation());
739  E->setTypeSourceInfo(readTypeSourceInfo());
740  for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
741  auto Kind = static_cast<OffsetOfNode::Kind>(Record.readInt());
742  SourceLocation Start = readSourceLocation();
743  SourceLocation End = readSourceLocation();
744  switch (Kind) {
745  case OffsetOfNode::Array:
746  E->setComponent(I, OffsetOfNode(Start, Record.readInt(), End));
747  break;
748 
749  case OffsetOfNode::Field:
750  E->setComponent(
751  I, OffsetOfNode(Start, readDeclAs<FieldDecl>(), End));
752  break;
753 
755  E->setComponent(
756  I,
757  OffsetOfNode(Start, Record.readIdentifier(), End));
758  break;
759 
760  case OffsetOfNode::Base: {
761  auto *Base = new (Record.getContext()) CXXBaseSpecifier();
762  *Base = Record.readCXXBaseSpecifier();
764  break;
765  }
766  }
767  }
768 
769  for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
770  E->setIndexExpr(I, Record.readSubExpr());
771 }
772 
773 void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
774  VisitExpr(E);
775  E->setKind(static_cast<UnaryExprOrTypeTrait>(Record.readInt()));
776  if (Record.peekInt() == 0) {
777  E->setArgument(Record.readSubExpr());
778  Record.skipInts(1);
779  } else {
780  E->setArgument(readTypeSourceInfo());
781  }
782  E->setOperatorLoc(readSourceLocation());
783  E->setRParenLoc(readSourceLocation());
784 }
785 
788  ConstraintSatisfaction Satisfaction;
789  Satisfaction.IsSatisfied = Record.readInt();
790  if (!Satisfaction.IsSatisfied) {
791  unsigned NumDetailRecords = Record.readInt();
792  for (unsigned i = 0; i != NumDetailRecords; ++i) {
793  Expr *ConstraintExpr = Record.readExpr();
794  if (/* IsDiagnostic */Record.readInt()) {
795  SourceLocation DiagLocation = Record.readSourceLocation();
796  std::string DiagMessage = Record.readString();
797  Satisfaction.Details.emplace_back(
798  ConstraintExpr, new (Record.getContext())
800  DiagLocation, DiagMessage});
801  } else
802  Satisfaction.Details.emplace_back(ConstraintExpr, Record.readExpr());
803  }
804  }
805  return Satisfaction;
806 }
807 
808 void ASTStmtReader::VisitConceptSpecializationExpr(
810  VisitExpr(E);
811  unsigned NumTemplateArgs = Record.readInt();
812  E->NestedNameSpec = Record.readNestedNameSpecifierLoc();
813  E->TemplateKWLoc = Record.readSourceLocation();
814  E->ConceptName = Record.readDeclarationNameInfo();
815  E->NamedConcept = readDeclAs<ConceptDecl>();
816  E->FoundDecl = Record.readDeclAs<NamedDecl>();
817  E->ArgsAsWritten = Record.readASTTemplateArgumentListInfo();
819  for (unsigned I = 0; I < NumTemplateArgs; ++I)
820  Args.push_back(Record.readTemplateArgument());
821  E->setTemplateArguments(Args);
822  E->Satisfaction = E->isValueDependent() ? nullptr :
823  ASTConstraintSatisfaction::Create(Record.getContext(),
825 }
826 
829  std::string SubstitutedEntity = Record.readString();
830  SourceLocation DiagLoc = Record.readSourceLocation();
831  std::string DiagMessage = Record.readString();
832  return new (Record.getContext())
833  concepts::Requirement::SubstitutionDiagnostic{SubstitutedEntity, DiagLoc,
834  DiagMessage};
835 }
836 
837 void ASTStmtReader::VisitRequiresExpr(RequiresExpr *E) {
838  VisitExpr(E);
839  unsigned NumLocalParameters = Record.readInt();
840  unsigned NumRequirements = Record.readInt();
841  E->RequiresExprBits.RequiresKWLoc = Record.readSourceLocation();
842  E->RequiresExprBits.IsSatisfied = Record.readInt();
843  E->Body = Record.readDeclAs<RequiresExprBodyDecl>();
844  llvm::SmallVector<ParmVarDecl *, 4> LocalParameters;
845  for (unsigned i = 0; i < NumLocalParameters; ++i)
846  LocalParameters.push_back(cast<ParmVarDecl>(Record.readDecl()));
847  std::copy(LocalParameters.begin(), LocalParameters.end(),
848  E->getTrailingObjects<ParmVarDecl *>());
850  for (unsigned i = 0; i < NumRequirements; ++i) {
851  auto RK =
852  static_cast<concepts::Requirement::RequirementKind>(Record.readInt());
853  concepts::Requirement *R = nullptr;
854  switch (RK) {
856  auto Status =
858  Record.readInt());
860  R = new (Record.getContext())
862  else
863  R = new (Record.getContext())
864  concepts::TypeRequirement(Record.readTypeSourceInfo());
865  } break;
868  auto Status =
870  Record.readInt());
872  Expr *> E;
874  E = readSubstitutionDiagnostic(Record);
875  } else
876  E = Record.readExpr();
877 
879  ConceptSpecializationExpr *SubstitutedConstraintExpr = nullptr;
880  SourceLocation NoexceptLoc;
882  Req.emplace();
883  } else {
884  NoexceptLoc = Record.readSourceLocation();
885  switch (/* returnTypeRequirementKind */Record.readInt()) {
886  case 0:
887  // No return type requirement.
888  Req.emplace();
889  break;
890  case 1: {
891  // type-constraint
892  TemplateParameterList *TPL = Record.readTemplateParameterList();
893  if (Status >=
895  SubstitutedConstraintExpr =
896  cast<ConceptSpecializationExpr>(Record.readExpr());
897  Req.emplace(TPL);
898  } break;
899  case 2:
900  // Substitution failure
901  Req.emplace(readSubstitutionDiagnostic(Record));
902  break;
903  }
904  }
905  if (Expr *Ex = E.dyn_cast<Expr *>())
906  R = new (Record.getContext()) concepts::ExprRequirement(
907  Ex, RK == concepts::Requirement::RK_Simple, NoexceptLoc,
908  std::move(*Req), Status, SubstitutedConstraintExpr);
909  else
910  R = new (Record.getContext()) concepts::ExprRequirement(
912  RK == concepts::Requirement::RK_Simple, NoexceptLoc,
913  std::move(*Req));
914  } break;
916  if (/* IsSubstitutionDiagnostic */Record.readInt()) {
917  R = new (Record.getContext()) concepts::NestedRequirement(
919  break;
920  }
921  Expr *E = Record.readExpr();
922  if (E->isInstantiationDependent())
923  R = new (Record.getContext()) concepts::NestedRequirement(E);
924  else
925  R = new (Record.getContext())
926  concepts::NestedRequirement(Record.getContext(), E,
928  } break;
929  }
930  if (!R)
931  continue;
932  Requirements.push_back(R);
933  }
934  std::copy(Requirements.begin(), Requirements.end(),
935  E->getTrailingObjects<concepts::Requirement *>());
936  E->RBraceLoc = Record.readSourceLocation();
937 }
938 
939 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
940  VisitExpr(E);
941  E->setLHS(Record.readSubExpr());
942  E->setRHS(Record.readSubExpr());
943  E->setRBracketLoc(readSourceLocation());
944 }
945 
946 void ASTStmtReader::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E) {
947  VisitExpr(E);
948  E->setBase(Record.readSubExpr());
949  E->setRowIdx(Record.readSubExpr());
950  E->setColumnIdx(Record.readSubExpr());
951  E->setRBracketLoc(readSourceLocation());
952 }
953 
954 void ASTStmtReader::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {
955  VisitExpr(E);
956  E->setBase(Record.readSubExpr());
957  E->setLowerBound(Record.readSubExpr());
958  E->setLength(Record.readSubExpr());
959  E->setStride(Record.readSubExpr());
960  E->setColonLocFirst(readSourceLocation());
961  E->setColonLocSecond(readSourceLocation());
962  E->setRBracketLoc(readSourceLocation());
963 }
964 
965 void ASTStmtReader::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
966  VisitExpr(E);
967  unsigned NumDims = Record.readInt();
968  E->setBase(Record.readSubExpr());
969  SmallVector<Expr *, 4> Dims(NumDims);
970  for (unsigned I = 0; I < NumDims; ++I)
971  Dims[I] = Record.readSubExpr();
972  E->setDimensions(Dims);
973  SmallVector<SourceRange, 4> SRs(NumDims);
974  for (unsigned I = 0; I < NumDims; ++I)
975  SRs[I] = readSourceRange();
976  E->setBracketsRanges(SRs);
977  E->setLParenLoc(readSourceLocation());
978  E->setRParenLoc(readSourceLocation());
979 }
980 
981 void ASTStmtReader::VisitOMPIteratorExpr(OMPIteratorExpr *E) {
982  VisitExpr(E);
983  unsigned NumIters = Record.readInt();
984  E->setIteratorKwLoc(readSourceLocation());
985  E->setLParenLoc(readSourceLocation());
986  E->setRParenLoc(readSourceLocation());
987  for (unsigned I = 0; I < NumIters; ++I) {
988  E->setIteratorDeclaration(I, Record.readDeclRef());
989  E->setAssignmentLoc(I, readSourceLocation());
990  Expr *Begin = Record.readSubExpr();
991  Expr *End = Record.readSubExpr();
992  Expr *Step = Record.readSubExpr();
993  SourceLocation ColonLoc = readSourceLocation();
994  SourceLocation SecColonLoc;
995  if (Step)
996  SecColonLoc = readSourceLocation();
997  E->setIteratorRange(I, Begin, ColonLoc, End, SecColonLoc, Step);
998  // Deserialize helpers
1000  HD.CounterVD = cast_or_null<VarDecl>(Record.readDeclRef());
1001  HD.Upper = Record.readSubExpr();
1002  HD.Update = Record.readSubExpr();
1003  HD.CounterUpdate = Record.readSubExpr();
1004  E->setHelper(I, HD);
1005  }
1006 }
1007 
1008 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
1009  VisitExpr(E);
1010  unsigned NumArgs = Record.readInt();
1011  bool HasFPFeatures = Record.readInt();
1012  assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
1013  E->setRParenLoc(readSourceLocation());
1014  E->setCallee(Record.readSubExpr());
1015  for (unsigned I = 0; I != NumArgs; ++I)
1016  E->setArg(I, Record.readSubExpr());
1017  E->setADLCallKind(static_cast<CallExpr::ADLCallKind>(Record.readInt()));
1018  if (HasFPFeatures)
1020  FPOptionsOverride::getFromOpaqueInt(Record.readInt()));
1021 }
1022 
1023 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1024  VisitCallExpr(E);
1025 }
1026 
1027 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
1028  VisitExpr(E);
1029 
1030  bool HasQualifier = Record.readInt();
1031  bool HasFoundDecl = Record.readInt();
1032  bool HasTemplateInfo = Record.readInt();
1033  unsigned NumTemplateArgs = Record.readInt();
1034 
1035  E->Base = Record.readSubExpr();
1036  E->MemberDecl = Record.readDeclAs<ValueDecl>();
1037  E->MemberDNLoc = Record.readDeclarationNameLoc(E->MemberDecl->getDeclName());
1038  E->MemberLoc = Record.readSourceLocation();
1039  E->MemberExprBits.IsArrow = Record.readInt();
1040  E->MemberExprBits.HasQualifierOrFoundDecl = HasQualifier || HasFoundDecl;
1041  E->MemberExprBits.HasTemplateKWAndArgsInfo = HasTemplateInfo;
1042  E->MemberExprBits.HadMultipleCandidates = Record.readInt();
1043  E->MemberExprBits.NonOdrUseReason = Record.readInt();
1044  E->MemberExprBits.OperatorLoc = Record.readSourceLocation();
1045 
1046  if (HasQualifier || HasFoundDecl) {
1047  DeclAccessPair FoundDecl;
1048  if (HasFoundDecl) {
1049  auto *FoundD = Record.readDeclAs<NamedDecl>();
1050  auto AS = (AccessSpecifier)Record.readInt();
1051  FoundDecl = DeclAccessPair::make(FoundD, AS);
1052  } else {
1053  FoundDecl = DeclAccessPair::make(E->MemberDecl,
1054  E->MemberDecl->getAccess());
1055  }
1056  E->getTrailingObjects<MemberExprNameQualifier>()->FoundDecl = FoundDecl;
1057 
1058  NestedNameSpecifierLoc QualifierLoc;
1059  if (HasQualifier)
1060  QualifierLoc = Record.readNestedNameSpecifierLoc();
1061  E->getTrailingObjects<MemberExprNameQualifier>()->QualifierLoc =
1062  QualifierLoc;
1063  }
1064 
1065  if (HasTemplateInfo)
1066  ReadTemplateKWAndArgsInfo(
1067  *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1068  E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
1069 }
1070 
1071 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
1072  VisitExpr(E);
1073  E->setBase(Record.readSubExpr());
1074  E->setIsaMemberLoc(readSourceLocation());
1075  E->setOpLoc(readSourceLocation());
1076  E->setArrow(Record.readInt());
1077 }
1078 
1079 void ASTStmtReader::
1080 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
1081  VisitExpr(E);
1082  E->Operand = Record.readSubExpr();
1083  E->setShouldCopy(Record.readInt());
1084 }
1085 
1086 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
1087  VisitExplicitCastExpr(E);
1088  E->LParenLoc = readSourceLocation();
1089  E->BridgeKeywordLoc = readSourceLocation();
1090  E->Kind = Record.readInt();
1091 }
1092 
1093 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
1094  VisitExpr(E);
1095  unsigned NumBaseSpecs = Record.readInt();
1096  assert(NumBaseSpecs == E->path_size());
1097  unsigned HasFPFeatures = Record.readInt();
1098  assert(E->hasStoredFPFeatures() == HasFPFeatures);
1099  E->setSubExpr(Record.readSubExpr());
1100  E->setCastKind((CastKind)Record.readInt());
1101  CastExpr::path_iterator BaseI = E->path_begin();
1102  while (NumBaseSpecs--) {
1103  auto *BaseSpec = new (Record.getContext()) CXXBaseSpecifier;
1104  *BaseSpec = Record.readCXXBaseSpecifier();
1105  *BaseI++ = BaseSpec;
1106  }
1107  if (HasFPFeatures)
1108  *E->getTrailingFPFeatures() =
1109  FPOptionsOverride::getFromOpaqueInt(Record.readInt());
1110 }
1111 
1112 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
1113  bool hasFP_Features;
1114  VisitExpr(E);
1115  E->setHasStoredFPFeatures(hasFP_Features = Record.readInt());
1116  E->setOpcode((BinaryOperator::Opcode)Record.readInt());
1117  E->setLHS(Record.readSubExpr());
1118  E->setRHS(Record.readSubExpr());
1119  E->setOperatorLoc(readSourceLocation());
1120  if (hasFP_Features)
1122  FPOptionsOverride::getFromOpaqueInt(Record.readInt()));
1123 }
1124 
1125 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
1126  VisitBinaryOperator(E);
1127  E->setComputationLHSType(Record.readType());
1128  E->setComputationResultType(Record.readType());
1129 }
1130 
1131 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
1132  VisitExpr(E);
1133  E->SubExprs[ConditionalOperator::COND] = Record.readSubExpr();
1134  E->SubExprs[ConditionalOperator::LHS] = Record.readSubExpr();
1135  E->SubExprs[ConditionalOperator::RHS] = Record.readSubExpr();
1136  E->QuestionLoc = readSourceLocation();
1137  E->ColonLoc = readSourceLocation();
1138 }
1139 
1140 void
1141 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
1142  VisitExpr(E);
1143  E->OpaqueValue = cast<OpaqueValueExpr>(Record.readSubExpr());
1144  E->SubExprs[BinaryConditionalOperator::COMMON] = Record.readSubExpr();
1145  E->SubExprs[BinaryConditionalOperator::COND] = Record.readSubExpr();
1146  E->SubExprs[BinaryConditionalOperator::LHS] = Record.readSubExpr();
1147  E->SubExprs[BinaryConditionalOperator::RHS] = Record.readSubExpr();
1148  E->QuestionLoc = readSourceLocation();
1149  E->ColonLoc = readSourceLocation();
1150 }
1151 
1152 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
1153  VisitCastExpr(E);
1154  E->setIsPartOfExplicitCast(Record.readInt());
1155 }
1156 
1157 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
1158  VisitCastExpr(E);
1159  E->setTypeInfoAsWritten(readTypeSourceInfo());
1160 }
1161 
1162 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
1163  VisitExplicitCastExpr(E);
1164  E->setLParenLoc(readSourceLocation());
1165  E->setRParenLoc(readSourceLocation());
1166 }
1167 
1168 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
1169  VisitExpr(E);
1170  E->setLParenLoc(readSourceLocation());
1171  E->setTypeSourceInfo(readTypeSourceInfo());
1172  E->setInitializer(Record.readSubExpr());
1173  E->setFileScope(Record.readInt());
1174 }
1175 
1176 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
1177  VisitExpr(E);
1178  E->setBase(Record.readSubExpr());
1179  E->setAccessor(Record.readIdentifier());
1180  E->setAccessorLoc(readSourceLocation());
1181 }
1182 
1183 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
1184  VisitExpr(E);
1185  if (auto *SyntForm = cast_or_null<InitListExpr>(Record.readSubStmt()))
1186  E->setSyntacticForm(SyntForm);
1187  E->setLBraceLoc(readSourceLocation());
1188  E->setRBraceLoc(readSourceLocation());
1189  bool isArrayFiller = Record.readInt();
1190  Expr *filler = nullptr;
1191  if (isArrayFiller) {
1192  filler = Record.readSubExpr();
1193  E->ArrayFillerOrUnionFieldInit = filler;
1194  } else
1195  E->ArrayFillerOrUnionFieldInit = readDeclAs<FieldDecl>();
1196  E->sawArrayRangeDesignator(Record.readInt());
1197  unsigned NumInits = Record.readInt();
1198  E->reserveInits(Record.getContext(), NumInits);
1199  if (isArrayFiller) {
1200  for (unsigned I = 0; I != NumInits; ++I) {
1201  Expr *init = Record.readSubExpr();
1202  E->updateInit(Record.getContext(), I, init ? init : filler);
1203  }
1204  } else {
1205  for (unsigned I = 0; I != NumInits; ++I)
1206  E->updateInit(Record.getContext(), I, Record.readSubExpr());
1207  }
1208 }
1209 
1210 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
1212 
1213  VisitExpr(E);
1214  unsigned NumSubExprs = Record.readInt();
1215  assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
1216  for (unsigned I = 0; I != NumSubExprs; ++I)
1217  E->setSubExpr(I, Record.readSubExpr());
1218  E->setEqualOrColonLoc(readSourceLocation());
1219  E->setGNUSyntax(Record.readInt());
1220 
1221  SmallVector<Designator, 4> Designators;
1222  while (Record.getIdx() < Record.size()) {
1223  switch ((DesignatorTypes)Record.readInt()) {
1224  case DESIG_FIELD_DECL: {
1225  auto *Field = readDeclAs<FieldDecl>();
1226  SourceLocation DotLoc = readSourceLocation();
1227  SourceLocation FieldLoc = readSourceLocation();
1228  Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
1229  FieldLoc));
1230  Designators.back().setField(Field);
1231  break;
1232  }
1233 
1234  case DESIG_FIELD_NAME: {
1235  const IdentifierInfo *Name = Record.readIdentifier();
1236  SourceLocation DotLoc = readSourceLocation();
1237  SourceLocation FieldLoc = readSourceLocation();
1238  Designators.push_back(Designator(Name, DotLoc, FieldLoc));
1239  break;
1240  }
1241 
1242  case DESIG_ARRAY: {
1243  unsigned Index = Record.readInt();
1244  SourceLocation LBracketLoc = readSourceLocation();
1245  SourceLocation RBracketLoc = readSourceLocation();
1246  Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
1247  break;
1248  }
1249 
1250  case DESIG_ARRAY_RANGE: {
1251  unsigned Index = Record.readInt();
1252  SourceLocation LBracketLoc = readSourceLocation();
1253  SourceLocation EllipsisLoc = readSourceLocation();
1254  SourceLocation RBracketLoc = readSourceLocation();
1255  Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
1256  RBracketLoc));
1257  break;
1258  }
1259  }
1260  }
1261  E->setDesignators(Record.getContext(),
1262  Designators.data(), Designators.size());
1263 }
1264 
1265 void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
1266  VisitExpr(E);
1267  E->setBase(Record.readSubExpr());
1268  E->setUpdater(Record.readSubExpr());
1269 }
1270 
1271 void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) {
1272  VisitExpr(E);
1273 }
1274 
1275 void ASTStmtReader::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
1276  VisitExpr(E);
1277  E->SubExprs[0] = Record.readSubExpr();
1278  E->SubExprs[1] = Record.readSubExpr();
1279 }
1280 
1281 void ASTStmtReader::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
1282  VisitExpr(E);
1283 }
1284 
1285 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
1286  VisitExpr(E);
1287 }
1288 
1289 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
1290  VisitExpr(E);
1291  E->setSubExpr(Record.readSubExpr());
1292  E->setWrittenTypeInfo(readTypeSourceInfo());
1293  E->setBuiltinLoc(readSourceLocation());
1294  E->setRParenLoc(readSourceLocation());
1295  E->setIsMicrosoftABI(Record.readInt());
1296 }
1297 
1298 void ASTStmtReader::VisitSourceLocExpr(SourceLocExpr *E) {
1299  VisitExpr(E);
1300  E->ParentContext = readDeclAs<DeclContext>();
1301  E->BuiltinLoc = readSourceLocation();
1302  E->RParenLoc = readSourceLocation();
1303  E->SourceLocExprBits.Kind =
1304  static_cast<SourceLocExpr::IdentKind>(Record.readInt());
1305 }
1306 
1307 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
1308  VisitExpr(E);
1309  E->setAmpAmpLoc(readSourceLocation());
1310  E->setLabelLoc(readSourceLocation());
1311  E->setLabel(readDeclAs<LabelDecl>());
1312 }
1313 
1314 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
1315  VisitExpr(E);
1316  E->setLParenLoc(readSourceLocation());
1317  E->setRParenLoc(readSourceLocation());
1318  E->setSubStmt(cast_or_null<CompoundStmt>(Record.readSubStmt()));
1319  E->StmtExprBits.TemplateDepth = Record.readInt();
1320 }
1321 
1322 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
1323  VisitExpr(E);
1324  E->setCond(Record.readSubExpr());
1325  E->setLHS(Record.readSubExpr());
1326  E->setRHS(Record.readSubExpr());
1327  E->setBuiltinLoc(readSourceLocation());
1328  E->setRParenLoc(readSourceLocation());
1329  E->setIsConditionTrue(Record.readInt());
1330 }
1331 
1332 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
1333  VisitExpr(E);
1334  E->setTokenLocation(readSourceLocation());
1335 }
1336 
1337 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
1338  VisitExpr(E);
1340  unsigned NumExprs = Record.readInt();
1341  while (NumExprs--)
1342  Exprs.push_back(Record.readSubExpr());
1343  E->setExprs(Record.getContext(), Exprs);
1344  E->setBuiltinLoc(readSourceLocation());
1345  E->setRParenLoc(readSourceLocation());
1346 }
1347 
1348 void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) {
1349  VisitExpr(E);
1350  E->BuiltinLoc = readSourceLocation();
1351  E->RParenLoc = readSourceLocation();
1352  E->TInfo = readTypeSourceInfo();
1353  E->SrcExpr = Record.readSubExpr();
1354 }
1355 
1356 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
1357  VisitExpr(E);
1358  E->setBlockDecl(readDeclAs<BlockDecl>());
1359 }
1360 
1361 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
1362  VisitExpr(E);
1363 
1364  unsigned NumAssocs = Record.readInt();
1365  assert(NumAssocs == E->getNumAssocs() && "Wrong NumAssocs!");
1366  E->ResultIndex = Record.readInt();
1367  E->GenericSelectionExprBits.GenericLoc = readSourceLocation();
1368  E->DefaultLoc = readSourceLocation();
1369  E->RParenLoc = readSourceLocation();
1370 
1371  Stmt **Stmts = E->getTrailingObjects<Stmt *>();
1372  // Add 1 to account for the controlling expression which is the first
1373  // expression in the trailing array of Stmt *. This is not needed for
1374  // the trailing array of TypeSourceInfo *.
1375  for (unsigned I = 0, N = NumAssocs + 1; I < N; ++I)
1376  Stmts[I] = Record.readSubExpr();
1377 
1378  TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>();
1379  for (unsigned I = 0, N = NumAssocs; I < N; ++I)
1380  TSIs[I] = readTypeSourceInfo();
1381 }
1382 
1383 void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
1384  VisitExpr(E);
1385  unsigned numSemanticExprs = Record.readInt();
1386  assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs);
1387  E->PseudoObjectExprBits.ResultIndex = Record.readInt();
1388 
1389  // Read the syntactic expression.
1390  E->getSubExprsBuffer()[0] = Record.readSubExpr();
1391 
1392  // Read all the semantic expressions.
1393  for (unsigned i = 0; i != numSemanticExprs; ++i) {
1394  Expr *subExpr = Record.readSubExpr();
1395  E->getSubExprsBuffer()[i+1] = subExpr;
1396  }
1397 }
1398 
1399 void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {
1400  VisitExpr(E);
1401  E->Op = AtomicExpr::AtomicOp(Record.readInt());
1402  E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op);
1403  for (unsigned I = 0; I != E->NumSubExprs; ++I)
1404  E->SubExprs[I] = Record.readSubExpr();
1405  E->BuiltinLoc = readSourceLocation();
1406  E->RParenLoc = readSourceLocation();
1407 }
1408 
1409 //===----------------------------------------------------------------------===//
1410 // Objective-C Expressions and Statements
1411 
1412 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
1413  VisitExpr(E);
1414  E->setString(cast<StringLiteral>(Record.readSubStmt()));
1415  E->setAtLoc(readSourceLocation());
1416 }
1417 
1418 void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
1419  VisitExpr(E);
1420  // could be one of several IntegerLiteral, FloatLiteral, etc.
1421  E->SubExpr = Record.readSubStmt();
1422  E->BoxingMethod = readDeclAs<ObjCMethodDecl>();
1423  E->Range = readSourceRange();
1424 }
1425 
1426 void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
1427  VisitExpr(E);
1428  unsigned NumElements = Record.readInt();
1429  assert(NumElements == E->getNumElements() && "Wrong number of elements");
1430  Expr **Elements = E->getElements();
1431  for (unsigned I = 0, N = NumElements; I != N; ++I)
1432  Elements[I] = Record.readSubExpr();
1433  E->ArrayWithObjectsMethod = readDeclAs<ObjCMethodDecl>();
1434  E->Range = readSourceRange();
1435 }
1436 
1437 void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
1438  VisitExpr(E);
1439  unsigned NumElements = Record.readInt();
1440  assert(NumElements == E->getNumElements() && "Wrong number of elements");
1441  bool HasPackExpansions = Record.readInt();
1442  assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch");
1443  auto *KeyValues =
1444  E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>();
1445  auto *Expansions =
1446  E->getTrailingObjects<ObjCDictionaryLiteral::ExpansionData>();
1447  for (unsigned I = 0; I != NumElements; ++I) {
1448  KeyValues[I].Key = Record.readSubExpr();
1449  KeyValues[I].Value = Record.readSubExpr();
1450  if (HasPackExpansions) {
1451  Expansions[I].EllipsisLoc = readSourceLocation();
1452  Expansions[I].NumExpansionsPlusOne = Record.readInt();
1453  }
1454  }
1455  E->DictWithObjectsMethod = readDeclAs<ObjCMethodDecl>();
1456  E->Range = readSourceRange();
1457 }
1458 
1459 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
1460  VisitExpr(E);
1461  E->setEncodedTypeSourceInfo(readTypeSourceInfo());
1462  E->setAtLoc(readSourceLocation());
1463  E->setRParenLoc(readSourceLocation());
1464 }
1465 
1466 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
1467  VisitExpr(E);
1468  E->setSelector(Record.readSelector());
1469  E->setAtLoc(readSourceLocation());
1470  E->setRParenLoc(readSourceLocation());
1471 }
1472 
1473 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
1474  VisitExpr(E);
1475  E->setProtocol(readDeclAs<ObjCProtocolDecl>());
1476  E->setAtLoc(readSourceLocation());
1477  E->ProtoLoc = readSourceLocation();
1478  E->setRParenLoc(readSourceLocation());
1479 }
1480 
1481 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
1482  VisitExpr(E);
1483  E->setDecl(readDeclAs<ObjCIvarDecl>());
1484  E->setLocation(readSourceLocation());
1485  E->setOpLoc(readSourceLocation());
1486  E->setBase(Record.readSubExpr());
1487  E->setIsArrow(Record.readInt());
1488  E->setIsFreeIvar(Record.readInt());
1489 }
1490 
1491 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
1492  VisitExpr(E);
1493  unsigned MethodRefFlags = Record.readInt();
1494  bool Implicit = Record.readInt() != 0;
1495  if (Implicit) {
1496  auto *Getter = readDeclAs<ObjCMethodDecl>();
1497  auto *Setter = readDeclAs<ObjCMethodDecl>();
1498  E->setImplicitProperty(Getter, Setter, MethodRefFlags);
1499  } else {
1500  E->setExplicitProperty(readDeclAs<ObjCPropertyDecl>(), MethodRefFlags);
1501  }
1502  E->setLocation(readSourceLocation());
1503  E->setReceiverLocation(readSourceLocation());
1504  switch (Record.readInt()) {
1505  case 0:
1506  E->setBase(Record.readSubExpr());
1507  break;
1508  case 1:
1509  E->setSuperReceiver(Record.readType());
1510  break;
1511  case 2:
1512  E->setClassReceiver(readDeclAs<ObjCInterfaceDecl>());
1513  break;
1514  }
1515 }
1516 
1517 void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1518  VisitExpr(E);
1519  E->setRBracket(readSourceLocation());
1520  E->setBaseExpr(Record.readSubExpr());
1521  E->setKeyExpr(Record.readSubExpr());
1522  E->GetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>();
1523  E->SetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>();
1524 }
1525 
1526 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1527  VisitExpr(E);
1528  assert(Record.peekInt() == E->getNumArgs());
1529  Record.skipInts(1);
1530  unsigned NumStoredSelLocs = Record.readInt();
1531  E->SelLocsKind = Record.readInt();
1532  E->setDelegateInitCall(Record.readInt());
1533  E->IsImplicit = Record.readInt();
1534  auto Kind = static_cast<ObjCMessageExpr::ReceiverKind>(Record.readInt());
1535  switch (Kind) {
1537  E->setInstanceReceiver(Record.readSubExpr());
1538  break;
1539 
1541  E->setClassReceiver(readTypeSourceInfo());
1542  break;
1543 
1546  QualType T = Record.readType();
1547  SourceLocation SuperLoc = readSourceLocation();
1548  E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
1549  break;
1550  }
1551  }
1552 
1553  assert(Kind == E->getReceiverKind());
1554 
1555  if (Record.readInt())
1556  E->setMethodDecl(readDeclAs<ObjCMethodDecl>());
1557  else
1558  E->setSelector(Record.readSelector());
1559 
1560  E->LBracLoc = readSourceLocation();
1561  E->RBracLoc = readSourceLocation();
1562 
1563  for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1564  E->setArg(I, Record.readSubExpr());
1565 
1566  SourceLocation *Locs = E->getStoredSelLocs();
1567  for (unsigned I = 0; I != NumStoredSelLocs; ++I)
1568  Locs[I] = readSourceLocation();
1569 }
1570 
1571 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
1572  VisitStmt(S);
1573  S->setElement(Record.readSubStmt());
1574  S->setCollection(Record.readSubExpr());
1575  S->setBody(Record.readSubStmt());
1576  S->setForLoc(readSourceLocation());
1577  S->setRParenLoc(readSourceLocation());
1578 }
1579 
1580 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
1581  VisitStmt(S);
1582  S->setCatchBody(Record.readSubStmt());
1583  S->setCatchParamDecl(readDeclAs<VarDecl>());
1584  S->setAtCatchLoc(readSourceLocation());
1585  S->setRParenLoc(readSourceLocation());
1586 }
1587 
1588 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
1589  VisitStmt(S);
1590  S->setFinallyBody(Record.readSubStmt());
1591  S->setAtFinallyLoc(readSourceLocation());
1592 }
1593 
1594 void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1595  VisitStmt(S); // FIXME: no test coverage.
1596  S->setSubStmt(Record.readSubStmt());
1597  S->setAtLoc(readSourceLocation());
1598 }
1599 
1600 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
1601  VisitStmt(S);
1602  assert(Record.peekInt() == S->getNumCatchStmts());
1603  Record.skipInts(1);
1604  bool HasFinally = Record.readInt();
1605  S->setTryBody(Record.readSubStmt());
1606  for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
1607  S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Record.readSubStmt()));
1608 
1609  if (HasFinally)
1610  S->setFinallyStmt(Record.readSubStmt());
1611  S->setAtTryLoc(readSourceLocation());
1612 }
1613 
1614 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1615  VisitStmt(S); // FIXME: no test coverage.
1616  S->setSynchExpr(Record.readSubStmt());
1617  S->setSynchBody(Record.readSubStmt());
1618  S->setAtSynchronizedLoc(readSourceLocation());
1619 }
1620 
1621 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
1622  VisitStmt(S); // FIXME: no test coverage.
1623  S->setThrowExpr(Record.readSubStmt());
1624  S->setThrowLoc(readSourceLocation());
1625 }
1626 
1627 void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1628  VisitExpr(E);
1629  E->setValue(Record.readInt());
1630  E->setLocation(readSourceLocation());
1631 }
1632 
1633 void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
1634  VisitExpr(E);
1635  SourceRange R = Record.readSourceRange();
1636  E->AtLoc = R.getBegin();
1637  E->RParen = R.getEnd();
1638  E->VersionToCheck = Record.readVersionTuple();
1639 }
1640 
1641 //===----------------------------------------------------------------------===//
1642 // C++ Expressions and Statements
1643 //===----------------------------------------------------------------------===//
1644 
1645 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
1646  VisitStmt(S);
1647  S->CatchLoc = readSourceLocation();
1648  S->ExceptionDecl = readDeclAs<VarDecl>();
1649  S->HandlerBlock = Record.readSubStmt();
1650 }
1651 
1652 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
1653  VisitStmt(S);
1654  assert(Record.peekInt() == S->getNumHandlers() && "NumStmtFields is wrong ?");
1655  Record.skipInts(1);
1656  S->TryLoc = readSourceLocation();
1657  S->getStmts()[0] = Record.readSubStmt();
1658  for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1659  S->getStmts()[i + 1] = Record.readSubStmt();
1660 }
1661 
1662 void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1663  VisitStmt(S);
1664  S->ForLoc = readSourceLocation();
1665  S->CoawaitLoc = readSourceLocation();
1666  S->ColonLoc = readSourceLocation();
1667  S->RParenLoc = readSourceLocation();
1668  S->setInit(Record.readSubStmt());
1669  S->setRangeStmt(Record.readSubStmt());
1670  S->setBeginStmt(Record.readSubStmt());
1671  S->setEndStmt(Record.readSubStmt());
1672  S->setCond(Record.readSubExpr());
1673  S->setInc(Record.readSubExpr());
1674  S->setLoopVarStmt(Record.readSubStmt());
1675  S->setBody(Record.readSubStmt());
1676 }
1677 
1678 void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1679  VisitStmt(S);
1680  S->KeywordLoc = readSourceLocation();
1681  S->IsIfExists = Record.readInt();
1682  S->QualifierLoc = Record.readNestedNameSpecifierLoc();
1683  S->NameInfo = Record.readDeclarationNameInfo();
1684  S->SubStmt = Record.readSubStmt();
1685 }
1686 
1687 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1688  VisitCallExpr(E);
1689  E->CXXOperatorCallExprBits.OperatorKind = Record.readInt();
1690  E->Range = Record.readSourceRange();
1691 }
1692 
1693 void ASTStmtReader::VisitCXXRewrittenBinaryOperator(
1695  VisitExpr(E);
1696  E->CXXRewrittenBinaryOperatorBits.IsReversed = Record.readInt();
1697  E->SemanticForm = Record.readSubExpr();
1698 }
1699 
1700 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
1701  VisitExpr(E);
1702 
1703  unsigned NumArgs = Record.readInt();
1704  assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
1705 
1706  E->CXXConstructExprBits.Elidable = Record.readInt();
1707  E->CXXConstructExprBits.HadMultipleCandidates = Record.readInt();
1708  E->CXXConstructExprBits.ListInitialization = Record.readInt();
1709  E->CXXConstructExprBits.StdInitListInitialization = Record.readInt();
1710  E->CXXConstructExprBits.ZeroInitialization = Record.readInt();
1711  E->CXXConstructExprBits.ConstructionKind = Record.readInt();
1712  E->CXXConstructExprBits.Loc = readSourceLocation();
1713  E->Constructor = readDeclAs<CXXConstructorDecl>();
1714  E->ParenOrBraceRange = readSourceRange();
1715 
1716  for (unsigned I = 0; I != NumArgs; ++I)
1717  E->setArg(I, Record.readSubExpr());
1718 }
1719 
1720 void ASTStmtReader::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
1721  VisitExpr(E);
1722  E->Constructor = readDeclAs<CXXConstructorDecl>();
1723  E->Loc = readSourceLocation();
1724  E->ConstructsVirtualBase = Record.readInt();
1725  E->InheritedFromVirtualBase = Record.readInt();
1726 }
1727 
1728 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1729  VisitCXXConstructExpr(E);
1730  E->TSI = readTypeSourceInfo();
1731 }
1732 
1733 void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {
1734  VisitExpr(E);
1735  unsigned NumCaptures = Record.readInt();
1736  (void)NumCaptures;
1737  assert(NumCaptures == E->LambdaExprBits.NumCaptures);
1738  E->IntroducerRange = readSourceRange();
1739  E->LambdaExprBits.CaptureDefault = Record.readInt();
1740  E->CaptureDefaultLoc = readSourceLocation();
1741  E->LambdaExprBits.ExplicitParams = Record.readInt();
1742  E->LambdaExprBits.ExplicitResultType = Record.readInt();
1743  E->ClosingBrace = readSourceLocation();
1744 
1745  // Read capture initializers.
1747  CEnd = E->capture_init_end();
1748  C != CEnd; ++C)
1749  *C = Record.readSubExpr();
1750 
1751  // The body will be lazily deserialized when needed from the call operator
1752  // declaration.
1753 }
1754 
1755 void
1756 ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1757  VisitExpr(E);
1758  E->SubExpr = Record.readSubExpr();
1759 }
1760 
1761 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1762  VisitExplicitCastExpr(E);
1763  SourceRange R = readSourceRange();
1764  E->Loc = R.getBegin();
1765  E->RParenLoc = R.getEnd();
1766  R = readSourceRange();
1767  E->AngleBrackets = R;
1768 }
1769 
1770 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1771  return VisitCXXNamedCastExpr(E);
1772 }
1773 
1774 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1775  return VisitCXXNamedCastExpr(E);
1776 }
1777 
1778 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1779  return VisitCXXNamedCastExpr(E);
1780 }
1781 
1782 void ASTStmtReader::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) {
1783  return VisitCXXNamedCastExpr(E);
1784 }
1785 
1786 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1787  return VisitCXXNamedCastExpr(E);
1788 }
1789 
1790 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1791  VisitExplicitCastExpr(E);
1792  E->setLParenLoc(readSourceLocation());
1793  E->setRParenLoc(readSourceLocation());
1794 }
1795 
1796 void ASTStmtReader::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) {
1797  VisitExplicitCastExpr(E);
1798  E->KWLoc = readSourceLocation();
1799  E->RParenLoc = readSourceLocation();
1800 }
1801 
1802 void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1803  VisitCallExpr(E);
1804  E->UDSuffixLoc = readSourceLocation();
1805 }
1806 
1807 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1808  VisitExpr(E);
1809  E->setValue(Record.readInt());
1810  E->setLocation(readSourceLocation());
1811 }
1812 
1813 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1814  VisitExpr(E);
1815  E->setLocation(readSourceLocation());
1816 }
1817 
1818 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1819  VisitExpr(E);
1820  E->setSourceRange(readSourceRange());
1821  if (E->isTypeOperand())
1822  E->Operand = readTypeSourceInfo();
1823  else
1824  E->Operand = Record.readSubExpr();
1825 }
1826 
1827 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1828  VisitExpr(E);
1829  E->setLocation(readSourceLocation());
1830  E->setImplicit(Record.readInt());
1831 }
1832 
1833 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1834  VisitExpr(E);
1835  E->CXXThrowExprBits.ThrowLoc = readSourceLocation();
1836  E->Operand = Record.readSubExpr();
1837  E->CXXThrowExprBits.IsThrownVariableInScope = Record.readInt();
1838 }
1839 
1840 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1841  VisitExpr(E);
1842  E->Param = readDeclAs<ParmVarDecl>();
1843  E->UsedContext = readDeclAs<DeclContext>();
1844  E->CXXDefaultArgExprBits.Loc = readSourceLocation();
1845 }
1846 
1847 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1848  VisitExpr(E);
1849  E->Field = readDeclAs<FieldDecl>();
1850  E->UsedContext = readDeclAs<DeclContext>();
1851  E->CXXDefaultInitExprBits.Loc = readSourceLocation();
1852 }
1853 
1854 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1855  VisitExpr(E);
1856  E->setTemporary(Record.readCXXTemporary());
1857  E->setSubExpr(Record.readSubExpr());
1858 }
1859 
1860 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1861  VisitExpr(E);
1862  E->TypeInfo = readTypeSourceInfo();
1863  E->CXXScalarValueInitExprBits.RParenLoc = readSourceLocation();
1864 }
1865 
1866 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1867  VisitExpr(E);
1868 
1869  bool IsArray = Record.readInt();
1870  bool HasInit = Record.readInt();
1871  unsigned NumPlacementArgs = Record.readInt();
1872  bool IsParenTypeId = Record.readInt();
1873 
1874  E->CXXNewExprBits.IsGlobalNew = Record.readInt();
1875  E->CXXNewExprBits.ShouldPassAlignment = Record.readInt();
1876  E->CXXNewExprBits.UsualArrayDeleteWantsSize = Record.readInt();
1877  E->CXXNewExprBits.StoredInitializationStyle = Record.readInt();
1878 
1879  assert((IsArray == E->isArray()) && "Wrong IsArray!");
1880  assert((HasInit == E->hasInitializer()) && "Wrong HasInit!");
1881  assert((NumPlacementArgs == E->getNumPlacementArgs()) &&
1882  "Wrong NumPlacementArgs!");
1883  assert((IsParenTypeId == E->isParenTypeId()) && "Wrong IsParenTypeId!");
1884  (void)IsArray;
1885  (void)HasInit;
1886  (void)NumPlacementArgs;
1887 
1888  E->setOperatorNew(readDeclAs<FunctionDecl>());
1889  E->setOperatorDelete(readDeclAs<FunctionDecl>());
1890  E->AllocatedTypeInfo = readTypeSourceInfo();
1891  if (IsParenTypeId)
1892  E->getTrailingObjects<SourceRange>()[0] = readSourceRange();
1893  E->Range = readSourceRange();
1894  E->DirectInitRange = readSourceRange();
1895 
1896  // Install all the subexpressions.
1898  N = E->raw_arg_end();
1899  I != N; ++I)
1900  *I = Record.readSubStmt();
1901 }
1902 
1903 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1904  VisitExpr(E);
1905  E->CXXDeleteExprBits.GlobalDelete = Record.readInt();
1906  E->CXXDeleteExprBits.ArrayForm = Record.readInt();
1907  E->CXXDeleteExprBits.ArrayFormAsWritten = Record.readInt();
1908  E->CXXDeleteExprBits.UsualArrayDeleteWantsSize = Record.readInt();
1909  E->OperatorDelete = readDeclAs<FunctionDecl>();
1910  E->Argument = Record.readSubExpr();
1911  E->CXXDeleteExprBits.Loc = readSourceLocation();
1912 }
1913 
1914 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1915  VisitExpr(E);
1916 
1917  E->Base = Record.readSubExpr();
1918  E->IsArrow = Record.readInt();
1919  E->OperatorLoc = readSourceLocation();
1920  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1921  E->ScopeType = readTypeSourceInfo();
1922  E->ColonColonLoc = readSourceLocation();
1923  E->TildeLoc = readSourceLocation();
1924 
1925  IdentifierInfo *II = Record.readIdentifier();
1926  if (II)
1927  E->setDestroyedType(II, readSourceLocation());
1928  else
1929  E->setDestroyedType(readTypeSourceInfo());
1930 }
1931 
1932 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
1933  VisitExpr(E);
1934 
1935  unsigned NumObjects = Record.readInt();
1936  assert(NumObjects == E->getNumObjects());
1937  for (unsigned i = 0; i != NumObjects; ++i) {
1938  unsigned CleanupKind = Record.readInt();
1940  if (CleanupKind == COK_Block)
1941  Obj = readDeclAs<BlockDecl>();
1942  else if (CleanupKind == COK_CompoundLiteral)
1943  Obj = cast<CompoundLiteralExpr>(Record.readSubExpr());
1944  else
1945  llvm_unreachable("unexpected cleanup object type");
1946  E->getTrailingObjects<ExprWithCleanups::CleanupObject>()[i] = Obj;
1947  }
1948 
1949  E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record.readInt();
1950  E->SubExpr = Record.readSubExpr();
1951 }
1952 
1953 void ASTStmtReader::VisitCXXDependentScopeMemberExpr(
1955  VisitExpr(E);
1956 
1957  bool HasTemplateKWAndArgsInfo = Record.readInt();
1958  unsigned NumTemplateArgs = Record.readInt();
1959  bool HasFirstQualifierFoundInScope = Record.readInt();
1960 
1961  assert((HasTemplateKWAndArgsInfo == E->hasTemplateKWAndArgsInfo()) &&
1962  "Wrong HasTemplateKWAndArgsInfo!");
1963  assert(
1964  (HasFirstQualifierFoundInScope == E->hasFirstQualifierFoundInScope()) &&
1965  "Wrong HasFirstQualifierFoundInScope!");
1966 
1967  if (HasTemplateKWAndArgsInfo)
1968  ReadTemplateKWAndArgsInfo(
1969  *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1970  E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
1971 
1972  assert((NumTemplateArgs == E->getNumTemplateArgs()) &&
1973  "Wrong NumTemplateArgs!");
1974 
1975  E->CXXDependentScopeMemberExprBits.IsArrow = Record.readInt();
1976  E->CXXDependentScopeMemberExprBits.OperatorLoc = readSourceLocation();
1977  E->BaseType = Record.readType();
1978  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1979  E->Base = Record.readSubExpr();
1980 
1981  if (HasFirstQualifierFoundInScope)
1982  *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>();
1983 
1984  E->MemberNameInfo = Record.readDeclarationNameInfo();
1985 }
1986 
1987 void
1988 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1989  VisitExpr(E);
1990 
1991  if (Record.readInt()) // HasTemplateKWAndArgsInfo
1992  ReadTemplateKWAndArgsInfo(
1993  *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1994  E->getTrailingObjects<TemplateArgumentLoc>(),
1995  /*NumTemplateArgs=*/Record.readInt());
1996 
1997  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1998  E->NameInfo = Record.readDeclarationNameInfo();
1999 }
2000 
2001 void
2002 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
2003  VisitExpr(E);
2004  assert(Record.peekInt() == E->getNumArgs() &&
2005  "Read wrong record during creation ?");
2006  Record.skipInts(1);
2007  for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
2008  E->setArg(I, Record.readSubExpr());
2009  E->TSI = readTypeSourceInfo();
2010  E->setLParenLoc(readSourceLocation());
2011  E->setRParenLoc(readSourceLocation());
2012 }
2013 
2014 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
2015  VisitExpr(E);
2016 
2017  unsigned NumResults = Record.readInt();
2018  bool HasTemplateKWAndArgsInfo = Record.readInt();
2019  assert((E->getNumDecls() == NumResults) && "Wrong NumResults!");
2020  assert((E->hasTemplateKWAndArgsInfo() == HasTemplateKWAndArgsInfo) &&
2021  "Wrong HasTemplateKWAndArgsInfo!");
2022 
2023  if (HasTemplateKWAndArgsInfo) {
2024  unsigned NumTemplateArgs = Record.readInt();
2025  ReadTemplateKWAndArgsInfo(*E->getTrailingASTTemplateKWAndArgsInfo(),
2027  NumTemplateArgs);
2028  assert((E->getNumTemplateArgs() == NumTemplateArgs) &&
2029  "Wrong NumTemplateArgs!");
2030  }
2031 
2032  UnresolvedSet<8> Decls;
2033  for (unsigned I = 0; I != NumResults; ++I) {
2034  auto *D = readDeclAs<NamedDecl>();
2035  auto AS = (AccessSpecifier)Record.readInt();
2036  Decls.addDecl(D, AS);
2037  }
2038 
2039  DeclAccessPair *Results = E->getTrailingResults();
2040  UnresolvedSetIterator Iter = Decls.begin();
2041  for (unsigned I = 0; I != NumResults; ++I) {
2042  Results[I] = (Iter + I).getPair();
2043  }
2044 
2045  E->NameInfo = Record.readDeclarationNameInfo();
2046  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2047 }
2048 
2049 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
2050  VisitOverloadExpr(E);
2051  E->UnresolvedMemberExprBits.IsArrow = Record.readInt();
2052  E->UnresolvedMemberExprBits.HasUnresolvedUsing = Record.readInt();
2053  E->Base = Record.readSubExpr();
2054  E->BaseType = Record.readType();
2055  E->OperatorLoc = readSourceLocation();
2056 }
2057 
2058 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
2059  VisitOverloadExpr(E);
2060  E->UnresolvedLookupExprBits.RequiresADL = Record.readInt();
2061  E->UnresolvedLookupExprBits.Overloaded = Record.readInt();
2062  E->NamingClass = readDeclAs<CXXRecordDecl>();
2063 }
2064 
2065 void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {
2066  VisitExpr(E);
2067  E->TypeTraitExprBits.NumArgs = Record.readInt();
2068  E->TypeTraitExprBits.Kind = Record.readInt();
2069  E->TypeTraitExprBits.Value = Record.readInt();
2070  SourceRange Range = readSourceRange();
2071  E->Loc = Range.getBegin();
2072  E->RParenLoc = Range.getEnd();
2073 
2074  auto **Args = E->getTrailingObjects<TypeSourceInfo *>();
2075  for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
2076  Args[I] = readTypeSourceInfo();
2077 }
2078 
2079 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
2080  VisitExpr(E);
2081  E->ATT = (ArrayTypeTrait)Record.readInt();
2082  E->Value = (unsigned int)Record.readInt();
2083  SourceRange Range = readSourceRange();
2084  E->Loc = Range.getBegin();
2085  E->RParen = Range.getEnd();
2086  E->QueriedType = readTypeSourceInfo();
2087  E->Dimension = Record.readSubExpr();
2088 }
2089 
2090 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
2091  VisitExpr(E);
2092  E->ET = (ExpressionTrait)Record.readInt();
2093  E->Value = (bool)Record.readInt();
2094  SourceRange Range = readSourceRange();
2095  E->QueriedExpression = Record.readSubExpr();
2096  E->Loc = Range.getBegin();
2097  E->RParen = Range.getEnd();
2098 }
2099 
2100 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
2101  VisitExpr(E);
2102  E->CXXNoexceptExprBits.Value = Record.readInt();
2103  E->Range = readSourceRange();
2104  E->Operand = Record.readSubExpr();
2105 }
2106 
2107 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
2108  VisitExpr(E);
2109  E->EllipsisLoc = readSourceLocation();
2110  E->NumExpansions = Record.readInt();
2111  E->Pattern = Record.readSubExpr();
2112 }
2113 
2114 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
2115  VisitExpr(E);
2116  unsigned NumPartialArgs = Record.readInt();
2117  E->OperatorLoc = readSourceLocation();
2118  E->PackLoc = readSourceLocation();
2119  E->RParenLoc = readSourceLocation();
2120  E->Pack = Record.readDeclAs<NamedDecl>();
2121  if (E->isPartiallySubstituted()) {
2122  assert(E->Length == NumPartialArgs);
2123  for (auto *I = E->getTrailingObjects<TemplateArgument>(),
2124  *E = I + NumPartialArgs;
2125  I != E; ++I)
2126  new (I) TemplateArgument(Record.readTemplateArgument());
2127  } else if (!E->isValueDependent()) {
2128  E->Length = Record.readInt();
2129  }
2130 }
2131 
2132 void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(
2134  VisitExpr(E);
2135  E->ParamAndRef.setPointer(readDeclAs<NonTypeTemplateParmDecl>());
2136  E->ParamAndRef.setInt(Record.readInt());
2137  E->SubstNonTypeTemplateParmExprBits.NameLoc = readSourceLocation();
2138  E->Replacement = Record.readSubExpr();
2139 }
2140 
2141 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
2143  VisitExpr(E);
2144  E->Param = readDeclAs<NonTypeTemplateParmDecl>();
2145  TemplateArgument ArgPack = Record.readTemplateArgument();
2146  if (ArgPack.getKind() != TemplateArgument::Pack)
2147  return;
2148 
2149  E->Arguments = ArgPack.pack_begin();
2150  E->NumArguments = ArgPack.pack_size();
2151  E->NameLoc = readSourceLocation();
2152 }
2153 
2154 void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
2155  VisitExpr(E);
2156  E->NumParameters = Record.readInt();
2157  E->ParamPack = readDeclAs<ParmVarDecl>();
2158  E->NameLoc = readSourceLocation();
2159  auto **Parms = E->getTrailingObjects<VarDecl *>();
2160  for (unsigned i = 0, n = E->NumParameters; i != n; ++i)
2161  Parms[i] = readDeclAs<VarDecl>();
2162 }
2163 
2164 void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
2165  VisitExpr(E);
2166  bool HasMaterialzedDecl = Record.readInt();
2167  if (HasMaterialzedDecl)
2168  E->State = cast<LifetimeExtendedTemporaryDecl>(Record.readDecl());
2169  else
2170  E->State = Record.readSubExpr();
2171 }
2172 
2173 void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {
2174  VisitExpr(E);
2175  E->LParenLoc = readSourceLocation();
2176  E->EllipsisLoc = readSourceLocation();
2177  E->RParenLoc = readSourceLocation();
2178  E->NumExpansions = Record.readInt();
2179  E->SubExprs[0] = Record.readSubExpr();
2180  E->SubExprs[1] = Record.readSubExpr();
2181  E->SubExprs[2] = Record.readSubExpr();
2182  E->Opcode = (BinaryOperatorKind)Record.readInt();
2183 }
2184 
2185 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
2186  VisitExpr(E);
2187  E->SourceExpr = Record.readSubExpr();
2188  E->OpaqueValueExprBits.Loc = readSourceLocation();
2189  E->setIsUnique(Record.readInt());
2190 }
2191 
2192 void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {
2193  llvm_unreachable("Cannot read TypoExpr nodes");
2194 }
2195 
2196 void ASTStmtReader::VisitRecoveryExpr(RecoveryExpr *E) {
2197  VisitExpr(E);
2198  unsigned NumArgs = Record.readInt();
2199  E->BeginLoc = readSourceLocation();
2200  E->EndLoc = readSourceLocation();
2201  assert((NumArgs + 0LL ==
2202  std::distance(E->children().begin(), E->children().end())) &&
2203  "Wrong NumArgs!");
2204  (void)NumArgs;
2205  for (Stmt *&Child : E->children())
2206  Child = Record.readSubStmt();
2207 }
2208 
2209 //===----------------------------------------------------------------------===//
2210 // Microsoft Expressions and Statements
2211 //===----------------------------------------------------------------------===//
2212 void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
2213  VisitExpr(E);
2214  E->IsArrow = (Record.readInt() != 0);
2215  E->BaseExpr = Record.readSubExpr();
2216  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2217  E->MemberLoc = readSourceLocation();
2218  E->TheDecl = readDeclAs<MSPropertyDecl>();
2219 }
2220 
2221 void ASTStmtReader::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
2222  VisitExpr(E);
2223  E->setBase(Record.readSubExpr());
2224  E->setIdx(Record.readSubExpr());
2225  E->setRBracketLoc(readSourceLocation());
2226 }
2227 
2228 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
2229  VisitExpr(E);
2230  E->setSourceRange(readSourceRange());
2231  E->Guid = readDeclAs<MSGuidDecl>();
2232  if (E->isTypeOperand())
2233  E->Operand = readTypeSourceInfo();
2234  else
2235  E->Operand = Record.readSubExpr();
2236 }
2237 
2238 void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
2239  VisitStmt(S);
2240  S->setLeaveLoc(readSourceLocation());
2241 }
2242 
2243 void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {
2244  VisitStmt(S);
2245  S->Loc = readSourceLocation();
2246  S->Children[SEHExceptStmt::FILTER_EXPR] = Record.readSubStmt();
2247  S->Children[SEHExceptStmt::BLOCK] = Record.readSubStmt();
2248 }
2249 
2250 void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
2251  VisitStmt(S);
2252  S->Loc = readSourceLocation();
2253  S->Block = Record.readSubStmt();
2254 }
2255 
2256 void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {
2257  VisitStmt(S);
2258  S->IsCXXTry = Record.readInt();
2259  S->TryLoc = readSourceLocation();
2260  S->Children[SEHTryStmt::TRY] = Record.readSubStmt();
2261  S->Children[SEHTryStmt::HANDLER] = Record.readSubStmt();
2262 }
2263 
2264 //===----------------------------------------------------------------------===//
2265 // CUDA Expressions and Statements
2266 //===----------------------------------------------------------------------===//
2267 
2268 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
2269  VisitCallExpr(E);
2270  E->setPreArg(CUDAKernelCallExpr::CONFIG, Record.readSubExpr());
2271 }
2272 
2273 //===----------------------------------------------------------------------===//
2274 // OpenCL Expressions and Statements.
2275 //===----------------------------------------------------------------------===//
2276 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
2277  VisitExpr(E);
2278  E->BuiltinLoc = readSourceLocation();
2279  E->RParenLoc = readSourceLocation();
2280  E->SrcExpr = Record.readSubExpr();
2281 }
2282 
2283 //===----------------------------------------------------------------------===//
2284 // OpenMP Directives.
2285 //===----------------------------------------------------------------------===//
2286 
2287 void ASTStmtReader::VisitOMPCanonicalLoop(OMPCanonicalLoop *S) {
2288  VisitStmt(S);
2289  for (Stmt *&SubStmt : S->SubStmts)
2290  SubStmt = Record.readSubStmt();
2291 }
2292 
2293 void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2294  Record.readOMPChildren(E->Data);
2295  E->setLocStart(readSourceLocation());
2296  E->setLocEnd(readSourceLocation());
2297 }
2298 
2299 void ASTStmtReader::VisitOMPLoopBasedDirective(OMPLoopBasedDirective *D) {
2300  VisitStmt(D);
2301  // Field CollapsedNum was read in ReadStmtFromStream.
2302  Record.skipInts(1);
2303  VisitOMPExecutableDirective(D);
2304 }
2305 
2306 void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) {
2307  VisitOMPLoopBasedDirective(D);
2308 }
2309 
2310 void ASTStmtReader::VisitOMPMetaDirective(OMPMetaDirective *D) {
2311  VisitStmt(D);
2312  // The NumClauses field was read in ReadStmtFromStream.
2313  Record.skipInts(1);
2314  VisitOMPExecutableDirective(D);
2315 }
2316 
2317 void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) {
2318  VisitStmt(D);
2319  VisitOMPExecutableDirective(D);
2320  D->setHasCancel(Record.readBool());
2321 }
2322 
2323 void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) {
2324  VisitOMPLoopDirective(D);
2325 }
2326 
2327 void ASTStmtReader::VisitOMPLoopTransformationDirective(
2329  VisitOMPLoopBasedDirective(D);
2330  D->setNumGeneratedLoops(Record.readUInt32());
2331 }
2332 
2333 void ASTStmtReader::VisitOMPTileDirective(OMPTileDirective *D) {
2334  VisitOMPLoopTransformationDirective(D);
2335 }
2336 
2337 void ASTStmtReader::VisitOMPUnrollDirective(OMPUnrollDirective *D) {
2338  VisitOMPLoopTransformationDirective(D);
2339 }
2340 
2341 void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) {
2342  VisitOMPLoopDirective(D);
2343  D->setHasCancel(Record.readBool());
2344 }
2345 
2346 void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
2347  VisitOMPLoopDirective(D);
2348 }
2349 
2350 void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
2351  VisitStmt(D);
2352  VisitOMPExecutableDirective(D);
2353  D->setHasCancel(Record.readBool());
2354 }
2355 
2356 void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) {
2357  VisitStmt(D);
2358  VisitOMPExecutableDirective(D);
2359  D->setHasCancel(Record.readBool());
2360 }
2361 
2362 void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) {
2363  VisitStmt(D);
2364  VisitOMPExecutableDirective(D);
2365 }
2366 
2367 void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) {
2368  VisitStmt(D);
2369  VisitOMPExecutableDirective(D);
2370 }
2371 
2372 void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2373  VisitStmt(D);
2374  VisitOMPExecutableDirective(D);
2375  D->DirName = Record.readDeclarationNameInfo();
2376 }
2377 
2378 void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2379  VisitOMPLoopDirective(D);
2380  D->setHasCancel(Record.readBool());
2381 }
2382 
2383 void ASTStmtReader::VisitOMPParallelForSimdDirective(
2385  VisitOMPLoopDirective(D);
2386 }
2387 
2388 void ASTStmtReader::VisitOMPParallelMasterDirective(
2390  VisitStmt(D);
2391  VisitOMPExecutableDirective(D);
2392 }
2393 
2394 void ASTStmtReader::VisitOMPParallelSectionsDirective(
2396  VisitStmt(D);
2397  VisitOMPExecutableDirective(D);
2398  D->setHasCancel(Record.readBool());
2399 }
2400 
2401 void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) {
2402  VisitStmt(D);
2403  VisitOMPExecutableDirective(D);
2404  D->setHasCancel(Record.readBool());
2405 }
2406 
2407 void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2408  VisitStmt(D);
2409  VisitOMPExecutableDirective(D);
2410 }
2411 
2412 void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2413  VisitStmt(D);
2414  VisitOMPExecutableDirective(D);
2415 }
2416 
2417 void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2418  VisitStmt(D);
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->IsXLHSInRHSPart = Record.readBool();
2451  D->IsPostfixUpdate = Record.readBool();
2452 }
2453 
2454 void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) {
2455  VisitStmt(D);
2456  VisitOMPExecutableDirective(D);
2457 }
2458 
2459 void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
2460  VisitStmt(D);
2461  VisitOMPExecutableDirective(D);
2462 }
2463 
2464 void ASTStmtReader::VisitOMPTargetEnterDataDirective(
2466  VisitStmt(D);
2467  VisitOMPExecutableDirective(D);
2468 }
2469 
2470 void ASTStmtReader::VisitOMPTargetExitDataDirective(
2472  VisitStmt(D);
2473  VisitOMPExecutableDirective(D);
2474 }
2475 
2476 void ASTStmtReader::VisitOMPTargetParallelDirective(
2478  VisitStmt(D);
2479  VisitOMPExecutableDirective(D);
2480  D->setHasCancel(Record.readBool());
2481 }
2482 
2483 void ASTStmtReader::VisitOMPTargetParallelForDirective(
2485  VisitOMPLoopDirective(D);
2486  D->setHasCancel(Record.readBool());
2487 }
2488 
2489 void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2490  VisitStmt(D);
2491  VisitOMPExecutableDirective(D);
2492 }
2493 
2494 void ASTStmtReader::VisitOMPCancellationPointDirective(
2496  VisitStmt(D);
2497  VisitOMPExecutableDirective(D);
2498  D->setCancelRegion(Record.readEnum<OpenMPDirectiveKind>());
2499 }
2500 
2501 void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) {
2502  VisitStmt(D);
2503  VisitOMPExecutableDirective(D);
2504  D->setCancelRegion(Record.readEnum<OpenMPDirectiveKind>());
2505 }
2506 
2507 void ASTStmtReader::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
2508  VisitOMPLoopDirective(D);
2509  D->setHasCancel(Record.readBool());
2510 }
2511 
2512 void ASTStmtReader::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
2513  VisitOMPLoopDirective(D);
2514 }
2515 
2516 void ASTStmtReader::VisitOMPMasterTaskLoopDirective(
2518  VisitOMPLoopDirective(D);
2519  D->setHasCancel(Record.readBool());
2520 }
2521 
2522 void ASTStmtReader::VisitOMPMasterTaskLoopSimdDirective(
2524  VisitOMPLoopDirective(D);
2525 }
2526 
2527 void ASTStmtReader::VisitOMPParallelMasterTaskLoopDirective(
2529  VisitOMPLoopDirective(D);
2530  D->setHasCancel(Record.readBool());
2531 }
2532 
2533 void ASTStmtReader::VisitOMPParallelMasterTaskLoopSimdDirective(
2535  VisitOMPLoopDirective(D);
2536 }
2537 
2538 void ASTStmtReader::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
2539  VisitOMPLoopDirective(D);
2540 }
2541 
2542 void ASTStmtReader::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) {
2543  VisitStmt(D);
2544  VisitOMPExecutableDirective(D);
2545 }
2546 
2547 void ASTStmtReader::VisitOMPDistributeParallelForDirective(
2549  VisitOMPLoopDirective(D);
2550  D->setHasCancel(Record.readBool());
2551 }
2552 
2553 void ASTStmtReader::VisitOMPDistributeParallelForSimdDirective(
2555  VisitOMPLoopDirective(D);
2556 }
2557 
2558 void ASTStmtReader::VisitOMPDistributeSimdDirective(
2560  VisitOMPLoopDirective(D);
2561 }
2562 
2563 void ASTStmtReader::VisitOMPTargetParallelForSimdDirective(
2565  VisitOMPLoopDirective(D);
2566 }
2567 
2568 void ASTStmtReader::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) {
2569  VisitOMPLoopDirective(D);
2570 }
2571 
2572 void ASTStmtReader::VisitOMPTeamsDistributeDirective(
2574  VisitOMPLoopDirective(D);
2575 }
2576 
2577 void ASTStmtReader::VisitOMPTeamsDistributeSimdDirective(
2579  VisitOMPLoopDirective(D);
2580 }
2581 
2582 void ASTStmtReader::VisitOMPTeamsDistributeParallelForSimdDirective(
2584  VisitOMPLoopDirective(D);
2585 }
2586 
2587 void ASTStmtReader::VisitOMPTeamsDistributeParallelForDirective(
2589  VisitOMPLoopDirective(D);
2590  D->setHasCancel(Record.readBool());
2591 }
2592 
2593 void ASTStmtReader::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) {
2594  VisitStmt(D);
2595  VisitOMPExecutableDirective(D);
2596 }
2597 
2598 void ASTStmtReader::VisitOMPTargetTeamsDistributeDirective(
2600  VisitOMPLoopDirective(D);
2601 }
2602 
2603 void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForDirective(
2605  VisitOMPLoopDirective(D);
2606  D->setHasCancel(Record.readBool());
2607 }
2608 
2609 void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
2611  VisitOMPLoopDirective(D);
2612 }
2613 
2614 void ASTStmtReader::VisitOMPTargetTeamsDistributeSimdDirective(
2616  VisitOMPLoopDirective(D);
2617 }
2618 
2619 void ASTStmtReader::VisitOMPInteropDirective(OMPInteropDirective *D) {
2620  VisitStmt(D);
2621  VisitOMPExecutableDirective(D);
2622 }
2623 
2624 void ASTStmtReader::VisitOMPDispatchDirective(OMPDispatchDirective *D) {
2625  VisitStmt(D);
2626  VisitOMPExecutableDirective(D);
2627  D->setTargetCallLoc(Record.readSourceLocation());
2628 }
2629 
2630 void ASTStmtReader::VisitOMPMaskedDirective(OMPMaskedDirective *D) {
2631  VisitStmt(D);
2632  VisitOMPExecutableDirective(D);
2633 }
2634 
2635 //===----------------------------------------------------------------------===//
2636 // ASTReader Implementation
2637 //===----------------------------------------------------------------------===//
2638 
2640  switch (ReadingKind) {
2641  case Read_None:
2642  llvm_unreachable("should not call this when not reading anything");
2643  case Read_Decl:
2644  case Read_Type:
2645  return ReadStmtFromStream(F);
2646  case Read_Stmt:
2647  return ReadSubStmt();
2648  }
2649 
2650  llvm_unreachable("ReadingKind not set ?");
2651 }
2652 
2654  return cast_or_null<Expr>(ReadStmt(F));
2655 }
2656 
2658  return cast_or_null<Expr>(ReadSubStmt());
2659 }
2660 
2661 // Within the bitstream, expressions are stored in Reverse Polish
2662 // Notation, with each of the subexpressions preceding the
2663 // expression they are stored in. Subexpressions are stored from last to first.
2664 // To evaluate expressions, we continue reading expressions and placing them on
2665 // the stack, with expressions having operands removing those operands from the
2666 // stack. Evaluation terminates when we see a STMT_STOP record, and
2667 // the single remaining expression on the stack is our result.
2668 Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
2669  ReadingKindTracker ReadingKind(Read_Stmt, *this);
2670  llvm::BitstreamCursor &Cursor = F.DeclsCursor;
2671 
2672  // Map of offset to previously deserialized stmt. The offset points
2673  // just after the stmt record.
2674  llvm::DenseMap<uint64_t, Stmt *> StmtEntries;
2675 
2676 #ifndef NDEBUG
2677  unsigned PrevNumStmts = StmtStack.size();
2678 #endif
2679 
2680  ASTRecordReader Record(*this, F);
2681  ASTStmtReader Reader(Record, Cursor);
2682  Stmt::EmptyShell Empty;
2683 
2684  while (true) {
2686  Cursor.advanceSkippingSubblocks();
2687  if (!MaybeEntry) {
2688  Error(toString(MaybeEntry.takeError()));
2689  return nullptr;
2690  }
2691  llvm::BitstreamEntry Entry = MaybeEntry.get();
2692 
2693  switch (Entry.Kind) {
2694  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
2696  Error("malformed block record in AST file");
2697  return nullptr;
2698  case llvm::BitstreamEntry::EndBlock:
2699  goto Done;
2700  case llvm::BitstreamEntry::Record:
2701  // The interesting case.
2702  break;
2703  }
2704 
2705  ASTContext &Context = getContext();
2706  Stmt *S = nullptr;
2707  bool Finished = false;
2708  bool IsStmtReference = false;
2709  Expected<unsigned> MaybeStmtCode = Record.readRecord(Cursor, Entry.ID);
2710  if (!MaybeStmtCode) {
2711  Error(toString(MaybeStmtCode.takeError()));
2712  return nullptr;
2713  }
2714  switch ((StmtCode)MaybeStmtCode.get()) {
2715  case STMT_STOP:
2716  Finished = true;
2717  break;
2718 
2719  case STMT_REF_PTR:
2720  IsStmtReference = true;
2721  assert(StmtEntries.find(Record[0]) != StmtEntries.end() &&
2722  "No stmt was recorded for this offset reference!");
2723  S = StmtEntries[Record.readInt()];
2724  break;
2725 
2726  case STMT_NULL_PTR:
2727  S = nullptr;
2728  break;
2729 
2730  case STMT_NULL:
2731  S = new (Context) NullStmt(Empty);
2732  break;
2733 
2734  case STMT_COMPOUND:
2736  Context, /*NumStmts=*/Record[ASTStmtReader::NumStmtFields]);
2737  break;
2738 
2739  case STMT_CASE:
2741  Context,
2742  /*CaseStmtIsGNURange*/ Record[ASTStmtReader::NumStmtFields + 3]);
2743  break;
2744 
2745  case STMT_DEFAULT:
2746  S = new (Context) DefaultStmt(Empty);
2747  break;
2748 
2749  case STMT_LABEL:
2750  S = new (Context) LabelStmt(Empty);
2751  break;
2752 
2753  case STMT_ATTRIBUTED:
2755  Context,
2756  /*NumAttrs*/Record[ASTStmtReader::NumStmtFields]);
2757  break;
2758 
2759  case STMT_IF:
2760  S = IfStmt::CreateEmpty(
2761  Context,
2762  /* HasElse=*/Record[ASTStmtReader::NumStmtFields],
2763  /* HasVar=*/Record[ASTStmtReader::NumStmtFields + 1],
2764  /* HasInit=*/Record[ASTStmtReader::NumStmtFields + 2]);
2765  break;
2766 
2767  case STMT_SWITCH:
2769  Context,
2770  /* HasInit=*/Record[ASTStmtReader::NumStmtFields],
2771  /* HasVar=*/Record[ASTStmtReader::NumStmtFields + 1]);
2772  break;
2773 
2774  case STMT_WHILE:
2776  Context,
2777  /* HasVar=*/Record[ASTStmtReader::NumStmtFields]);
2778  break;
2779 
2780  case STMT_DO:
2781  S = new (Context) DoStmt(Empty);
2782  break;
2783 
2784  case STMT_FOR:
2785  S = new (Context) ForStmt(Empty);
2786  break;
2787 
2788  case STMT_GOTO:
2789  S = new (Context) GotoStmt(Empty);
2790  break;
2791 
2792  case STMT_INDIRECT_GOTO:
2793  S = new (Context) IndirectGotoStmt(Empty);
2794  break;
2795 
2796  case STMT_CONTINUE:
2797  S = new (Context) ContinueStmt(Empty);
2798  break;
2799 
2800  case STMT_BREAK:
2801  S = new (Context) BreakStmt(Empty);
2802  break;
2803 
2804  case STMT_RETURN:
2806  Context, /* HasNRVOCandidate=*/Record[ASTStmtReader::NumStmtFields]);
2807  break;
2808 
2809  case STMT_DECL:
2810  S = new (Context) DeclStmt(Empty);
2811  break;
2812 
2813  case STMT_GCCASM:
2814  S = new (Context) GCCAsmStmt(Empty);
2815  break;
2816 
2817  case STMT_MSASM:
2818  S = new (Context) MSAsmStmt(Empty);
2819  break;
2820 
2821  case STMT_CAPTURED:
2823  Context, Record[ASTStmtReader::NumStmtFields]);
2824  break;
2825 
2826  case EXPR_CONSTANT:
2828  Context, static_cast<ConstantExpr::ResultStorageKind>(
2829  /*StorageKind=*/Record[ASTStmtReader::NumExprFields]));
2830  break;
2831 
2834  break;
2835 
2836  case EXPR_PREDEFINED:
2838  Context,
2839  /*HasFunctionName*/ Record[ASTStmtReader::NumExprFields]);
2840  break;
2841 
2842  case EXPR_DECL_REF:
2844  Context,
2845  /*HasQualifier=*/Record[ASTStmtReader::NumExprFields],
2846  /*HasFoundDecl=*/Record[ASTStmtReader::NumExprFields + 1],
2847  /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 2],
2848  /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ?
2849  Record[ASTStmtReader::NumExprFields + 6] : 0);
2850  break;
2851 
2852  case EXPR_INTEGER_LITERAL:
2853  S = IntegerLiteral::Create(Context, Empty);
2854  break;
2855 
2857  S = FixedPointLiteral::Create(Context, Empty);
2858  break;
2859 
2860  case EXPR_FLOATING_LITERAL:
2861  S = FloatingLiteral::Create(Context, Empty);
2862  break;
2863 
2865  S = new (Context) ImaginaryLiteral(Empty);
2866  break;
2867 
2868  case EXPR_STRING_LITERAL:
2870  Context,
2871  /* NumConcatenated=*/Record[ASTStmtReader::NumExprFields],
2872  /* Length=*/Record[ASTStmtReader::NumExprFields + 1],
2873  /* CharByteWidth=*/Record[ASTStmtReader::NumExprFields + 2]);
2874  break;
2875 
2877  S = new (Context) CharacterLiteral(Empty);
2878  break;
2879 
2880  case EXPR_PAREN:
2881  S = new (Context) ParenExpr(Empty);
2882  break;
2883 
2884  case EXPR_PAREN_LIST:
2886  Context,
2887  /* NumExprs=*/Record[ASTStmtReader::NumExprFields]);
2888  break;
2889 
2890  case EXPR_UNARY_OPERATOR:
2891  S = UnaryOperator::CreateEmpty(Context,
2893  break;
2894 
2895  case EXPR_OFFSETOF:
2896  S = OffsetOfExpr::CreateEmpty(Context,
2898  Record[ASTStmtReader::NumExprFields + 1]);
2899  break;
2900 
2901  case EXPR_SIZEOF_ALIGN_OF:
2902  S = new (Context) UnaryExprOrTypeTraitExpr(Empty);
2903  break;
2904 
2905  case EXPR_ARRAY_SUBSCRIPT:
2906  S = new (Context) ArraySubscriptExpr(Empty);
2907  break;
2908 
2909  case EXPR_MATRIX_SUBSCRIPT:
2910  S = new (Context) MatrixSubscriptExpr(Empty);
2911  break;
2912 
2914  S = new (Context) OMPArraySectionExpr(Empty);
2915  break;
2916 
2919  Context, Record[ASTStmtReader::NumExprFields]);
2920  break;
2921 
2922  case EXPR_OMP_ITERATOR:
2923  S = OMPIteratorExpr::CreateEmpty(Context,
2925  break;
2926 
2927  case EXPR_CALL:
2929  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields],
2930  /*HasFPFeatures=*/Record[ASTStmtReader::NumExprFields + 1], Empty);
2931  break;
2932 
2933  case EXPR_RECOVERY:
2935  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
2936  break;
2937 
2938  case EXPR_MEMBER:
2940  Record[ASTStmtReader::NumExprFields + 1],
2941  Record[ASTStmtReader::NumExprFields + 2],
2942  Record[ASTStmtReader::NumExprFields + 3]);
2943  break;
2944 
2945  case EXPR_BINARY_OPERATOR:
2946  S = BinaryOperator::CreateEmpty(Context,
2948  break;
2949 
2952  Context, Record[ASTStmtReader::NumExprFields]);
2953  break;
2954 
2956  S = new (Context) ConditionalOperator(Empty);
2957  break;
2958 
2960  S = new (Context) BinaryConditionalOperator(Empty);
2961  break;
2962 
2963  case EXPR_IMPLICIT_CAST:
2965  Context,
2966  /*PathSize*/ Record[ASTStmtReader::NumExprFields],
2967  /*HasFPFeatures*/ Record[ASTStmtReader::NumExprFields + 1]);
2968  break;
2969 
2970  case EXPR_CSTYLE_CAST:
2972  Context,
2973  /*PathSize*/ Record[ASTStmtReader::NumExprFields],
2974  /*HasFPFeatures*/ Record[ASTStmtReader::NumExprFields + 1]);
2975  break;
2976 
2977  case EXPR_COMPOUND_LITERAL:
2978  S = new (Context) CompoundLiteralExpr(Empty);
2979  break;
2980 
2982  S = new (Context) ExtVectorElementExpr(Empty);
2983  break;
2984 
2985  case EXPR_INIT_LIST:
2986  S = new (Context) InitListExpr(Empty);
2987  break;
2988 
2989  case EXPR_DESIGNATED_INIT:
2990  S = DesignatedInitExpr::CreateEmpty(Context,
2991  Record[ASTStmtReader::NumExprFields] - 1);
2992 
2993  break;
2994 
2996  S = new (Context) DesignatedInitUpdateExpr(Empty);
2997  break;
2998 
3000  S = new (Context) ImplicitValueInitExpr(Empty);
3001  break;
3002 
3003  case EXPR_NO_INIT:
3004  S = new (Context) NoInitExpr(Empty);
3005  break;
3006 
3007  case EXPR_ARRAY_INIT_LOOP:
3008  S = new (Context) ArrayInitLoopExpr(Empty);
3009  break;
3010 
3011  case EXPR_ARRAY_INIT_INDEX:
3012  S = new (Context) ArrayInitIndexExpr(Empty);
3013  break;
3014 
3015  case EXPR_VA_ARG:
3016  S = new (Context) VAArgExpr(Empty);
3017  break;
3018 
3019  case EXPR_SOURCE_LOC:
3020  S = new (Context) SourceLocExpr(Empty);
3021  break;
3022 
3023  case EXPR_ADDR_LABEL:
3024  S = new (Context) AddrLabelExpr(Empty);
3025  break;
3026 
3027  case EXPR_STMT:
3028  S = new (Context) StmtExpr(Empty);
3029  break;
3030 
3031  case EXPR_CHOOSE:
3032  S = new (Context) ChooseExpr(Empty);
3033  break;
3034 
3035  case EXPR_GNU_NULL:
3036  S = new (Context) GNUNullExpr(Empty);
3037  break;
3038 
3039  case EXPR_SHUFFLE_VECTOR:
3040  S = new (Context) ShuffleVectorExpr(Empty);
3041  break;
3042 
3043  case EXPR_CONVERT_VECTOR:
3044  S = new (Context) ConvertVectorExpr(Empty);
3045  break;
3046 
3047  case EXPR_BLOCK:
3048  S = new (Context) BlockExpr(Empty);
3049  break;
3050 
3053  Context,
3054  /*NumAssocs=*/Record[ASTStmtReader::NumExprFields]);
3055  break;
3056 
3058  S = new (Context) ObjCStringLiteral(Empty);
3059  break;
3060 
3062  S = new (Context) ObjCBoxedExpr(Empty);
3063  break;
3064 
3066  S = ObjCArrayLiteral::CreateEmpty(Context,
3068  break;
3069 
3073  Record[ASTStmtReader::NumExprFields + 1]);
3074  break;
3075 
3076  case EXPR_OBJC_ENCODE:
3077  S = new (Context) ObjCEncodeExpr(Empty);
3078  break;
3079 
3081  S = new (Context) ObjCSelectorExpr(Empty);
3082  break;
3083 
3085  S = new (Context) ObjCProtocolExpr(Empty);
3086  break;
3087 
3089  S = new (Context) ObjCIvarRefExpr(Empty);
3090  break;
3091 
3093  S = new (Context) ObjCPropertyRefExpr(Empty);
3094  break;
3095 
3097  S = new (Context) ObjCSubscriptRefExpr(Empty);
3098  break;
3099 
3101  llvm_unreachable("mismatching AST file");
3102 
3104  S = ObjCMessageExpr::CreateEmpty(Context,
3106  Record[ASTStmtReader::NumExprFields + 1]);
3107  break;
3108 
3109  case EXPR_OBJC_ISA:
3110  S = new (Context) ObjCIsaExpr(Empty);
3111  break;
3112 
3114  S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);
3115  break;
3116 
3118  S = new (Context) ObjCBridgedCastExpr(Empty);
3119  break;
3120 
3122  S = new (Context) ObjCForCollectionStmt(Empty);
3123  break;
3124 
3125  case STMT_OBJC_CATCH:
3126  S = new (Context) ObjCAtCatchStmt(Empty);
3127  break;
3128 
3129  case STMT_OBJC_FINALLY:
3130  S = new (Context) ObjCAtFinallyStmt(Empty);
3131  break;
3132 
3133  case STMT_OBJC_AT_TRY:
3134  S = ObjCAtTryStmt::CreateEmpty(Context,
3136  Record[ASTStmtReader::NumStmtFields + 1]);
3137  break;
3138 
3140  S = new (Context) ObjCAtSynchronizedStmt(Empty);
3141  break;
3142 
3143  case STMT_OBJC_AT_THROW:
3144  S = new (Context) ObjCAtThrowStmt(Empty);
3145  break;
3146 
3148  S = new (Context) ObjCAutoreleasePoolStmt(Empty);
3149  break;
3150 
3152  S = new (Context) ObjCBoolLiteralExpr(Empty);
3153  break;
3154 
3156  S = new (Context) ObjCAvailabilityCheckExpr(Empty);
3157  break;
3158 
3159  case STMT_SEH_LEAVE:
3160  S = new (Context) SEHLeaveStmt(Empty);
3161  break;
3162 
3163  case STMT_SEH_EXCEPT:
3164  S = new (Context) SEHExceptStmt(Empty);
3165  break;
3166 
3167  case STMT_SEH_FINALLY:
3168  S = new (Context) SEHFinallyStmt(Empty);
3169  break;
3170 
3171  case STMT_SEH_TRY:
3172  S = new (Context) SEHTryStmt(Empty);
3173  break;
3174 
3175  case STMT_CXX_CATCH:
3176  S = new (Context) CXXCatchStmt(Empty);
3177  break;
3178 
3179  case STMT_CXX_TRY:
3180  S = CXXTryStmt::Create(Context, Empty,
3181  /*numHandlers=*/Record[ASTStmtReader::NumStmtFields]);
3182  break;
3183 
3184  case STMT_CXX_FOR_RANGE:
3185  S = new (Context) CXXForRangeStmt(Empty);
3186  break;
3187 
3189  S = new (Context) MSDependentExistsStmt(SourceLocation(), true,
3192  nullptr);
3193  break;
3194 
3196  S = OMPCanonicalLoop::createEmpty(Context);
3197  break;
3198 
3201  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3202  break;
3203 
3205  S =
3208  Empty);
3209  break;
3210 
3211  case STMT_OMP_SIMD_DIRECTIVE: {
3212  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3213  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3214  S = OMPSimdDirective::CreateEmpty(Context, NumClauses,
3215  CollapsedNum, Empty);
3216  break;
3217  }
3218 
3219  case STMT_OMP_TILE_DIRECTIVE: {
3220  unsigned NumLoops = Record[ASTStmtReader::NumStmtFields];
3221  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3222  S = OMPTileDirective::CreateEmpty(Context, NumClauses, NumLoops);
3223  break;
3224  }
3225 
3227  assert(Record[ASTStmtReader::NumStmtFields] == 1 && "Unroll directive accepts only a single loop");
3228  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3229  S = OMPUnrollDirective::CreateEmpty(Context, NumClauses);
3230  break;
3231  }
3232 
3233  case STMT_OMP_FOR_DIRECTIVE: {
3234  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3235  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3236  S = OMPForDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3237  Empty);
3238  break;
3239  }
3240 
3242  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3243  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3244  S = OMPForSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3245  Empty);
3246  break;
3247  }
3248 
3251  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3252  break;
3253 
3255  S = OMPSectionDirective::CreateEmpty(Context, Empty);
3256  break;
3257 
3260  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3261  break;
3262 
3264  S = OMPMasterDirective::CreateEmpty(Context, Empty);
3265  break;
3266 
3269  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3270  break;
3271 
3273  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3274  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3275  S = OMPParallelForDirective::CreateEmpty(Context, NumClauses,
3276  CollapsedNum, Empty);
3277  break;
3278  }
3279 
3281  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3282  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3283  S = OMPParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3284  CollapsedNum, Empty);
3285  break;
3286  }
3287 
3290  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3291  break;
3292 
3295  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3296  break;
3297 
3300  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3301  break;
3302 
3304  S = OMPTaskyieldDirective::CreateEmpty(Context, Empty);
3305  break;
3306 
3308  S = OMPBarrierDirective::CreateEmpty(Context, Empty);
3309  break;
3310 
3312  S = OMPTaskwaitDirective::CreateEmpty(Context, Empty);
3313  break;
3314 
3317  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3318  break;
3319 
3322  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3323  break;
3324 
3327  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3328  break;
3329 
3332  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3333  break;
3334 
3336  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3337  bool HasAssociatedStmt = Record[ASTStmtReader::NumStmtFields + 2];
3338  S = OMPOrderedDirective::CreateEmpty(Context, NumClauses,
3339  !HasAssociatedStmt, Empty);
3340  break;
3341  }
3342 
3345  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3346  break;
3347 
3350  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3351  break;
3352 
3355  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3356  break;
3357 
3360  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3361  break;
3362 
3365  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3366  break;
3367 
3370  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3371  break;
3372 
3374  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3375  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3376  S = OMPTargetParallelForDirective::CreateEmpty(Context, NumClauses,
3377  CollapsedNum, Empty);
3378  break;
3379  }
3380 
3383  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3384  break;
3385 
3388  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3389  break;
3390 
3392  S = OMPCancellationPointDirective::CreateEmpty(Context, Empty);
3393  break;
3394 
3397  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3398  break;
3399 
3401  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3402  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3403  S = OMPTaskLoopDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3404  Empty);
3405  break;
3406  }
3407 
3409  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3410  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3411  S = OMPTaskLoopSimdDirective::CreateEmpty(Context, NumClauses,
3412  CollapsedNum, Empty);
3413  break;
3414  }
3415 
3417  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3418  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3419  S = OMPMasterTaskLoopDirective::CreateEmpty(Context, NumClauses,
3420  CollapsedNum, Empty);
3421  break;
3422  }
3423 
3425  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3426  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3427  S = OMPMasterTaskLoopSimdDirective::CreateEmpty(Context, NumClauses,
3428  CollapsedNum, Empty);
3429  break;
3430  }
3431 
3433  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3434  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3435  S = OMPParallelMasterTaskLoopDirective::CreateEmpty(Context, NumClauses,
3436  CollapsedNum, Empty);
3437  break;
3438  }
3439 
3441  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3442  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3444  Context, NumClauses, CollapsedNum, Empty);
3445  break;
3446  }
3447 
3449  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3450  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3451  S = OMPDistributeDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3452  Empty);
3453  break;
3454  }
3455 
3457  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3458  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3459  S = OMPDistributeParallelForDirective::CreateEmpty(Context, NumClauses,
3460  CollapsedNum, Empty);
3461  break;
3462  }
3463 
3465  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3466  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3468  CollapsedNum,
3469  Empty);
3470  break;
3471  }
3472 
3474  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3475  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3476  S = OMPDistributeSimdDirective::CreateEmpty(Context, NumClauses,
3477  CollapsedNum, Empty);
3478  break;
3479  }
3480 
3482  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3483  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3484  S = OMPTargetParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3485  CollapsedNum, Empty);
3486  break;
3487  }
3488 
3490  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3491  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3492  S = OMPTargetSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3493  Empty);
3494  break;
3495  }
3496 
3498  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3499  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3500  S = OMPTeamsDistributeDirective::CreateEmpty(Context, NumClauses,
3501  CollapsedNum, Empty);
3502  break;
3503  }
3504 
3506  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3507  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3508  S = OMPTeamsDistributeSimdDirective::CreateEmpty(Context, NumClauses,
3509  CollapsedNum, Empty);
3510  break;
3511  }
3512 
3514  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3515  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3517  Context, NumClauses, CollapsedNum, Empty);
3518  break;
3519  }
3520 
3522  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3523  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3525  Context, NumClauses, CollapsedNum, Empty);
3526  break;
3527  }
3528 
3531  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3532  break;
3533 
3535  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3536  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3537  S = OMPTargetTeamsDistributeDirective::CreateEmpty(Context, NumClauses,
3538  CollapsedNum, Empty);
3539  break;
3540  }
3541 
3543  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3544  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3546  Context, NumClauses, CollapsedNum, Empty);
3547  break;
3548  }
3549 
3551  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3552  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3554  Context, NumClauses, CollapsedNum, Empty);
3555  break;
3556  }
3557 
3559  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3560  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3562  Context, NumClauses, CollapsedNum, Empty);
3563  break;
3564  }
3565 
3568  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3569  break;
3570 
3573  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3574  break;
3575 
3578  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3579  break;
3580 
3583  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields],
3584  /*HasFPFeatures=*/Record[ASTStmtReader::NumExprFields + 1], Empty);
3585  break;
3586 
3587  case EXPR_CXX_MEMBER_CALL:
3589  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields],
3590  /*HasFPFeatures=*/Record[ASTStmtReader::NumExprFields + 1], Empty);
3591  break;
3592 
3594  S = new (Context) CXXRewrittenBinaryOperator(Empty);
3595  break;
3596 
3597  case EXPR_CXX_CONSTRUCT:
3599  Context,
3600  /* NumArgs=*/Record[ASTStmtReader::NumExprFields]);
3601  break;
3602 
3604  S = new (Context) CXXInheritedCtorInitExpr(Empty);
3605  break;
3606 
3609  Context,
3610  /* NumArgs=*/Record[ASTStmtReader::NumExprFields]);
3611  break;
3612 
3613  case EXPR_CXX_STATIC_CAST:
3615  Context,
3616  /*PathSize*/ Record[ASTStmtReader::NumExprFields],
3617  /*HasFPFeatures*/ Record[ASTStmtReader::NumExprFields + 1]);
3618  break;
3619 
3620  case EXPR_CXX_DYNAMIC_CAST:
3621  S = CXXDynamicCastExpr::CreateEmpty(Context,
3622  /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3623  break;
3624 
3627  /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3628  break;
3629 
3630  case EXPR_CXX_CONST_CAST:
3631  S = CXXConstCastExpr::CreateEmpty(Context);
3632  break;
3633 
3635  S = CXXAddrspaceCastExpr::CreateEmpty(Context);
3636  break;
3637 
3640  Context,
3641  /*PathSize*/ Record[ASTStmtReader::NumExprFields],
3642  /*HasFPFeatures*/ Record[ASTStmtReader::NumExprFields + 1]);
3643  break;
3644 
3645  case EXPR_BUILTIN_BIT_CAST:
3646  assert(Record[ASTStmtReader::NumExprFields] == 0 && "Wrong PathSize!");
3647  S = new (Context) BuiltinBitCastExpr(Empty);
3648  break;
3649 
3652  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields],
3653  /*HasFPFeatures=*/Record[ASTStmtReader::NumExprFields + 1], Empty);
3654  break;
3655 
3657  S = new (Context) CXXStdInitializerListExpr(Empty);
3658  break;
3659 
3660  case EXPR_CXX_BOOL_LITERAL:
3661  S = new (Context) CXXBoolLiteralExpr(Empty);
3662  break;
3663 
3665  S = new (Context) CXXNullPtrLiteralExpr(Empty);
3666  break;
3667 
3668  case EXPR_CXX_TYPEID_EXPR:
3669  S = new (Context) CXXTypeidExpr(Empty, true);
3670  break;
3671 
3672  case EXPR_CXX_TYPEID_TYPE:
3673  S = new (Context) CXXTypeidExpr(Empty, false);
3674  break;
3675 
3676  case EXPR_CXX_UUIDOF_EXPR:
3677  S = new (Context) CXXUuidofExpr(Empty, true);
3678  break;
3679 
3681  S = new (Context) MSPropertyRefExpr(Empty);
3682  break;
3683 
3685  S = new (Context) MSPropertySubscriptExpr(Empty);
3686  break;
3687 
3688  case EXPR_CXX_UUIDOF_TYPE:
3689  S = new (Context) CXXUuidofExpr(Empty, false);
3690  break;
3691 
3692  case EXPR_CXX_THIS:
3693  S = new (Context) CXXThisExpr(Empty);
3694  break;
3695 
3696  case EXPR_CXX_THROW:
3697  S = new (Context) CXXThrowExpr(Empty);
3698  break;
3699 
3700  case EXPR_CXX_DEFAULT_ARG:
3701  S = new (Context) CXXDefaultArgExpr(Empty);
3702  break;
3703 
3704  case EXPR_CXX_DEFAULT_INIT:
3705  S = new (Context) CXXDefaultInitExpr(Empty);
3706  break;
3707 
3709  S = new (Context) CXXBindTemporaryExpr(Empty);
3710  break;
3711 
3713  S = new (Context) CXXScalarValueInitExpr(Empty);
3714  break;
3715 
3716  case EXPR_CXX_NEW:
3718  Context,
3719  /*IsArray=*/Record[ASTStmtReader::NumExprFields],
3720  /*HasInit=*/Record[ASTStmtReader::NumExprFields + 1],
3721  /*NumPlacementArgs=*/Record[ASTStmtReader::NumExprFields + 2],
3722  /*IsParenTypeId=*/Record[ASTStmtReader::NumExprFields + 3]);
3723  break;
3724 
3725  case EXPR_CXX_DELETE:
3726  S = new (Context) CXXDeleteExpr(Empty);
3727  break;
3728 
3730  S = new (Context) CXXPseudoDestructorExpr(Empty);
3731  break;
3732 
3734  S = ExprWithCleanups::Create(Context, Empty,
3736  break;
3737 
3740  Context,
3741  /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3742  /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 1],
3743  /*HasFirstQualifierFoundInScope=*/
3744  Record[ASTStmtReader::NumExprFields + 2]);
3745  break;
3746 
3749  /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3750  /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3751  ? Record[ASTStmtReader::NumExprFields + 1]
3752  : 0);
3753  break;
3754 
3757  /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
3758  break;
3759 
3762  Context,
3763  /*NumResults=*/Record[ASTStmtReader::NumExprFields],
3764  /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 1],
3765  /*NumTemplateArgs=*/
3766  Record[ASTStmtReader::NumExprFields + 1]
3767  ? Record[ASTStmtReader::NumExprFields + 2]
3768  : 0);
3769  break;
3770 
3773  Context,
3774  /*NumResults=*/Record[ASTStmtReader::NumExprFields],
3775  /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 1],
3776  /*NumTemplateArgs=*/
3777  Record[ASTStmtReader::NumExprFields + 1]
3778  ? Record[ASTStmtReader::NumExprFields + 2]
3779  : 0);
3780  break;
3781 
3782  case EXPR_TYPE_TRAIT:
3785  break;
3786 
3787  case EXPR_ARRAY_TYPE_TRAIT:
3788  S = new (Context) ArrayTypeTraitExpr(Empty);
3789  break;
3790 
3792  S = new (Context) ExpressionTraitExpr(Empty);
3793  break;
3794 
3795  case EXPR_CXX_NOEXCEPT:
3796  S = new (Context) CXXNoexceptExpr(Empty);
3797  break;
3798 
3799  case EXPR_PACK_EXPANSION:
3800  S = new (Context) PackExpansionExpr(Empty);
3801  break;
3802 
3803  case EXPR_SIZEOF_PACK:
3805  Context,
3806  /*NumPartialArgs=*/Record[ASTStmtReader::NumExprFields]);
3807  break;
3808 
3810  S = new (Context) SubstNonTypeTemplateParmExpr(Empty);
3811  break;
3812 
3814  S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
3815  break;
3816 
3820  break;
3821 
3823  S = new (Context) MaterializeTemporaryExpr(Empty);
3824  break;
3825 
3826  case EXPR_CXX_FOLD:
3827  S = new (Context) CXXFoldExpr(Empty);
3828  break;
3829 
3830  case EXPR_OPAQUE_VALUE:
3831  S = new (Context) OpaqueValueExpr(Empty);
3832  break;
3833 
3834  case EXPR_CUDA_KERNEL_CALL:
3836  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields],
3837  /*HasFPFeatures=*/Record[ASTStmtReader::NumExprFields + 1], Empty);
3838  break;
3839 
3840  case EXPR_ASTYPE:
3841  S = new (Context) AsTypeExpr(Empty);
3842  break;
3843 
3844  case EXPR_PSEUDO_OBJECT: {
3845  unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields];
3846  S = PseudoObjectExpr::Create(Context, Empty, numSemanticExprs);
3847  break;
3848  }
3849 
3850  case EXPR_ATOMIC:
3851  S = new (Context) AtomicExpr(Empty);
3852  break;
3853 
3854  case EXPR_LAMBDA: {
3855  unsigned NumCaptures = Record[ASTStmtReader::NumExprFields];
3856  S = LambdaExpr::CreateDeserialized(Context, NumCaptures);
3857  break;
3858  }
3859 
3860  case STMT_COROUTINE_BODY: {
3861  unsigned NumParams = Record[ASTStmtReader::NumStmtFields];
3862  S = CoroutineBodyStmt::Create(Context, Empty, NumParams);
3863  break;
3864  }
3865 
3866  case STMT_CORETURN:
3867  S = new (Context) CoreturnStmt(Empty);
3868  break;
3869 
3870  case EXPR_COAWAIT:
3871  S = new (Context) CoawaitExpr(Empty);
3872  break;
3873 
3874  case EXPR_COYIELD:
3875  S = new (Context) CoyieldExpr(Empty);
3876  break;
3877 
3879  S = new (Context) DependentCoawaitExpr(Empty);
3880  break;
3881 
3883  unsigned numTemplateArgs = Record[ASTStmtReader::NumExprFields];
3884  S = ConceptSpecializationExpr::Create(Context, Empty, numTemplateArgs);
3885  break;
3886  }
3887 
3888  case EXPR_REQUIRES:
3889  unsigned numLocalParameters = Record[ASTStmtReader::NumExprFields];
3890  unsigned numRequirement = Record[ASTStmtReader::NumExprFields + 1];
3891  S = RequiresExpr::Create(Context, Empty, numLocalParameters,
3892  numRequirement);
3893  break;
3894  }
3895 
3896  // We hit a STMT_STOP, so we're done with this expression.
3897  if (Finished)
3898  break;
3899 
3900  ++NumStatementsRead;
3901 
3902  if (S && !IsStmtReference) {
3903  Reader.Visit(S);
3904  StmtEntries[Cursor.GetCurrentBitNo()] = S;
3905  }
3906 
3907  assert(Record.getIdx() == Record.size() &&
3908  "Invalid deserialization of statement");
3909  StmtStack.push_back(S);
3910  }
3911 Done:
3912  assert(StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!");
3913  assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
3914  return StmtStack.pop_back_val();
3915 }
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:5469
clang::OMPIteratorExpr::setLParenLoc
void setLParenLoc(SourceLocation L)
Definition: ExprOpenMP.h:367
clang::CompoundLiteralExpr::setLParenLoc
void setLParenLoc(SourceLocation L)
Definition: Expr.h:3434
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:1016
clang::IndirectGotoStmt
IndirectGotoStmt - This represents an indirect goto.
Definition: Stmt.h:2644
clang::LabelStmt
LabelStmt - Represents a label, which has a substatement.
Definition: Stmt.h:1799
clang::serialization::EXPR_CHARACTER_LITERAL
@ EXPR_CHARACTER_LITERAL
A CharacterLiteral record.
Definition: ASTBitCodes.h:1607
clang::serialization::STMT_CXX_TRY
@ STMT_CXX_TRY
A CXXTryStmt record.
Definition: ASTBitCodes.h:1789
clang::ExpressionTraitExpr
An expression trait intrinsic.
Definition: ExprCXX.h:2823
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:1607
clang::CallExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: Expr.h:3110
clang::concepts::Requirement::RequirementKind
RequirementKind
Definition: ExprConcepts.h:153
clang::serialization::STMT_MS_DEPENDENT_EXISTS
@ STMT_MS_DEPENDENT_EXISTS
Definition: ASTBitCodes.h:1967
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:2717
clang::SubstNonTypeTemplateParmExpr
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:4245
clang::RecoveryExpr::children
child_range children()
Definition: Expr.h:6429
clang::serialization::STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE
@ STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE
Definition: ASTBitCodes.h:1930
clang::AtomicExpr
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...
Definition: Expr.h:6229
clang::OMPMasterTaskLoopSimdDirective
This represents '#pragma omp master taskloop simd' directive.
Definition: StmtOpenMP.h:3724
clang::CaseStmt
CaseStmt - Represent a case statement.
Definition: Stmt.h:1567
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:2438
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:1739
clang::ImaginaryLiteral
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....
Definition: Expr.h:1712
clang::serialization::EXPR_PSEUDO_OBJECT
@ EXPR_PSEUDO_OBJECT
A PseudoObjectExpr record.
Definition: ASTBitCodes.h:1709
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:1574
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:5387
clang::ArrayTypeTraitExpr
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent.
Definition: ExprCXX.h:2753
clang::ASTRecordReader::getContext
ASTContext & getContext()
Retrieve the AST context that this AST reader supplements.
Definition: ASTRecordReader.h:56
clang::ObjCBoxedExpr
ObjCBoxedExpr - used for generalized expression boxing.
Definition: ExprObjC.h:128
clang::CallExpr::setPreArg
void setPreArg(unsigned I, Stmt *PreArg)
Definition: Expr.h:2883
clang::CaseStmt::CreateEmpty
static CaseStmt * CreateEmpty(const ASTContext &Ctx, bool CaseStmtIsGNURange)
Build an empty case statement.
Definition: Stmt.cpp:1222
clang::CXXBoolLiteralExpr
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition: ExprCXX.h:721
clang::CharacterLiteral::CharacterKind
CharacterKind
Definition: Expr.h:1580
clang::OverloadExpr::getTrailingASTTemplateKWAndArgsInfo
ASTTemplateKWAndArgsInfo * getTrailingASTTemplateKWAndArgsInfo()
Return the optional template keyword and arguments info.
Definition: ExprCXX.h:3970
clang::OffsetOfExpr::setComponent
void setComponent(unsigned Idx, OffsetOfNode ON)
Definition: Expr.h:2492
clang::serialization::EXPR_GENERIC_SELECTION
@ EXPR_GENERIC_SELECTION
A GenericSelectionExpr record.
Definition: ASTBitCodes.h:1706
clang::PredefinedExpr::CreateEmpty
static PredefinedExpr * CreateEmpty(const ASTContext &Ctx, bool HasFunctionName)
Create an empty PredefinedExpr.
Definition: Expr.cpp:592
clang::AsTypeExpr
AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2] This AST node provides support ...
Definition: Expr.h:6026
clang::OffsetOfExpr
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type,...
Definition: Expr.h:2438
Specifiers.h
clang::serialization::STMT_CAPTURED
@ STMT_CAPTURED
A CapturedStmt record.
Definition: ASTBitCodes.h:1577
clang::serialization::STMT_OMP_TARGET_DATA_DIRECTIVE
@ STMT_OMP_TARGET_DATA_DIRECTIVE
Definition: ASTBitCodes.h:1926
clang::serialization::STMT_CASE
@ STMT_CASE
A CaseStmt record.
Definition: ASTBitCodes.h:1532
clang::CXXPseudoDestructorExpr
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Definition: ExprCXX.h:2517
clang::FloatingLiteral::setValue
void setValue(const ASTContext &C, const llvm::APFloat &Val)
Definition: Expr.h:1650
clang::ChooseExpr::setCond
void setCond(Expr *E)
Definition: Expr.h:4561
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:1001
clang::CoawaitExpr::setIsImplicit
void setIsImplicit(bool value=true)
Definition: ExprCXX.h:4791
clang::SYCLUniqueStableNameExpr::CreateEmpty
static SYCLUniqueStableNameExpr * CreateEmpty(const ASTContext &Ctx)
Definition: Expr.cpp:534
clang::serialization::EXPR_INTEGER_LITERAL
@ EXPR_INTEGER_LITERAL
An IntegerLiteral record.
Definition: ASTBitCodes.h:1595
clang::serialization::EXPR_SHUFFLE_VECTOR
@ EXPR_SHUFFLE_VECTOR
A ShuffleVectorExpr record.
Definition: ASTBitCodes.h:1697
clang::OMPTileDirective
This represents the '#pragma omp tile' loop transformation directive.
Definition: StmtOpenMP.h:5056
clang::SwitchStmt
SwitchStmt - This represents a 'switch' stmt.
Definition: Stmt.h:2150
clang::serialization::STMT_OBJC_AT_THROW
@ STMT_OBJC_AT_THROW
An ObjCAtThrowStmt record.
Definition: ASTBitCodes.h:1772
clang::SourceLocExpr::IdentKind
IdentKind
Definition: Expr.h:4683
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:5383
Error
llvm::Error Error
Definition: ByteCodeEmitter.cpp:20
clang::serialization::EXPR_CXX_UNRESOLVED_LOOKUP
@ EXPR_CXX_UNRESOLVED_LOOKUP
Definition: ASTBitCodes.h:1862
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:212
clang::serialization::EXPR_OMP_ARRAY_SECTION
@ EXPR_OMP_ARRAY_SECTION
Definition: ASTBitCodes.h:1960
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:1055
clang::Stmt::PseudoObjectExprBits
PseudoObjectExprBitfields PseudoObjectExprBits
Definition: Stmt.h:1039
clang::WhileStmt
WhileStmt - This represents a 'while' stmt.
Definition: Stmt.h:2341
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:4846
clang::NullStmt
NullStmt - This is the null statement ";": C99 6.8.3p3.
Definition: Stmt.h:1364
clang::serialization::STMT_NULL
@ STMT_NULL
A NullStmt record.
Definition: ASTBitCodes.h:1526
clang::serialization::STMT_OMP_CANONICAL_LOOP
@ STMT_OMP_CANONICAL_LOOP
Definition: ASTBitCodes.h:1900
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:1126
clang::serialization::EXPR_CXX_UNRESOLVED_MEMBER
@ EXPR_CXX_UNRESOLVED_MEMBER
Definition: ASTBitCodes.h:1861
clang::serialization::STMT_MSASM
@ STMT_MSASM
A MS-style AsmStmt record.
Definition: ASTBitCodes.h:1583
clang::OMPCancelDirective::CreateEmpty
static OMPCancelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:793
clang::serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE
@ STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1955
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:1618
clang::TypeTraitExpr::getNumArgs
unsigned getNumArgs() const
Determine the number of arguments to this type trait.
Definition: ExprCXX.h:2714
clang::CXXConstructExpr::getNumArgs
unsigned getNumArgs() const
Return the number of arguments to the constructor call.
Definition: ExprCXX.h:1608
clang::serialization::EXPR_CONVERT_VECTOR
@ EXPR_CONVERT_VECTOR
A ConvertVectorExpr record.
Definition: ASTBitCodes.h:1700
clang::CXXBoolLiteralExpr::setValue
void setValue(bool V)
Definition: ExprCXX.h:734
clang::TemplateArgument::pack_begin
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
Definition: TemplateBase.h:352
DependenceFlags.h
clang::OMPParallelMasterTaskLoopDirective
This represents '#pragma omp parallel master taskloop' directive.
Definition: StmtOpenMP.h:3790
clang::serialization::EXPR_PACK_EXPANSION
@ EXPR_PACK_EXPANSION
Definition: ASTBitCodes.h:1872
clang::serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF
@ EXPR_CXX_DEPENDENT_SCOPE_DECL_REF
Definition: ASTBitCodes.h:1859
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:1462
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:1649
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:1643
clang::DesignatedInitExpr
Represents a C99 designated initializer expression.
Definition: Expr.h:5024
clang::OMPTargetTeamsDistributeDirective
This represents '#pragma omp target teams distribute' combined directive.
Definition: StmtOpenMP.h:4763
clang::concepts::TypeRequirement::SS_SubstitutionFailure
@ SS_SubstitutionFailure
Definition: ExprConcepts.h:207
clang::SubstNonTypeTemplateParmPackExpr
Represents a reference to a non-type template parameter pack that has been substituted with a non-tem...
Definition: ExprCXX.h:4312
clang::UnresolvedMemberExpr::CreateEmpty
static UnresolvedMemberExpr * CreateEmpty(const ASTContext &Context, unsigned NumResults, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
Definition: ExprCXX.cpp:1515
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:823
clang::OMPTargetTeamsDistributeSimdDirective
This represents '#pragma omp target teams distribute simd' combined directive.
Definition: StmtOpenMP.h:4998
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:1938
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:88
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:923
clang::DeclGroup::Create
static DeclGroup * Create(ASTContext &C, Decl **Decls, unsigned NumDecls)
Definition: DeclGroup.cpp:20
clang::Stmt::GenericSelectionExprBits
GenericSelectionExprBitfields GenericSelectionExprBits
Definition: Stmt.h:1038
clang::AttributedStmt::CreateEmpty
static AttributedStmt * CreateEmpty(const ASTContext &C, unsigned NumAttrs)
Definition: Stmt.cpp:425
clang::DesignatedInitExpr::setSubExpr
void setSubExpr(unsigned Idx, Expr *E)
Definition: Expr.h:5284
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:912
clang::ASTRecordReader
An object for streaming information from a record.
Definition: ASTRecordReader.h:30
clang::NamedDecl
This represents a decl that may have a name.
Definition: Decl.h:249
clang::serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE
@ STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1956
clang::Stmt::CXXOperatorCallExprBits
CXXOperatorCallExprBitfields CXXOperatorCallExprBits
Definition: Stmt.h:1046
clang::ObjCStringLiteral::setString
void setString(StringLiteral *S)
Definition: ExprObjC.h:67
clang::ParenListExpr
Definition: Expr.h:5532
clang::SourceRange::getBegin
SourceLocation getBegin() const
Definition: SourceLocation.h:221
clang::StmtExpr::setSubStmt
void setSubStmt(CompoundStmt *S)
Definition: Expr.h:4364
clang::serialization::EXPR_OBJC_BOOL_LITERAL
@ EXPR_OBJC_BOOL_LITERAL
An ObjCBoolLiteralExpr record.
Definition: ASTBitCodes.h:1778
clang::OMPMasterDirective
This represents '#pragma omp master' directive.
Definition: StmtOpenMP.h:1950
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:1604
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:1147
clang::OffsetOfExpr::CreateEmpty
static OffsetOfExpr * CreateEmpty(const ASTContext &C, unsigned NumComps, unsigned NumExprs)
Definition: Expr.cpp:1584
clang::CXXNewExpr::getNumPlacementArgs
unsigned getNumPlacementArgs() const
Definition: ExprCXX.h:2275
clang::ExprWithCleanups::getNumObjects
unsigned getNumObjects() const
Definition: ExprCXX.h:3375
clang::ArraySubscriptExpr::setLHS
void setLHS(Expr *E)
Definition: Expr.h:2670
clang::CharacterLiteral::setLocation
void setLocation(SourceLocation Location)
Definition: Expr.h:1614
clang::NoInitExpr
Represents a place-holder for an object not to be initialized by anything.
Definition: Expr.h:5325
clang::InitListExpr::reserveInits
void reserveInits(const ASTContext &C, unsigned NumInits)
Reserve space for some number of initializers.
Definition: Expr.cpp:2261
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:2339
clang::OMPTaskwaitDirective
This represents '#pragma omp taskwait' directive.
Definition: StmtOpenMP.h:2530
ExpressionTraits.h
clang::UnresolvedMemberExpr
Represents a C++ member access expression for which lookup produced a set of overloaded functions.
Definition: ExprCXX.h:3810
clang::serialization::STMT_FOR
@ STMT_FOR
A ForStmt record.
Definition: ASTBitCodes.h:1556
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:673
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:1664
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:1723
clang::Stmt::TypeTraitExprBits
TypeTraitExprBitfields TypeTraitExprBits
Definition: Stmt.h:1057
AttributeLangSupport::C
@ C
Definition: SemaDeclAttr.cpp:54
clang::CXXNewExpr::isArray
bool isArray() const
Definition: ExprCXX.h:2262
clang::serialization::STMT_OBJC_AT_SYNCHRONIZED
@ STMT_OBJC_AT_SYNCHRONIZED
An ObjCAtSynchronizedStmt record.
Definition: ASTBitCodes.h:1769
clang::OMPSectionDirective
This represents '#pragma omp section' directive.
Definition: StmtOpenMP.h:1837
Cursor
Cursor
Definition: SerializedDiagnosticReader.cpp:109
clang::serialization::EXPR_CXX_PROPERTY_REF_EXPR
@ EXPR_CXX_PROPERTY_REF_EXPR
Definition: ASTBitCodes.h:1889
clang::serialization::EXPR_IMPLICIT_VALUE_INIT
@ EXPR_IMPLICIT_VALUE_INIT
An ImplicitValueInitExpr record.
Definition: ASTBitCodes.h:1676
clang::serialization::EXPR_CXX_FUNCTIONAL_CAST
@ EXPR_CXX_FUNCTIONAL_CAST
A CXXFunctionalCastExpr record.
Definition: ASTBitCodes.h:1828
clang::TypeTraitExpr
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
Definition: ExprCXX.h:2665
clang::serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK
@ EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK
Definition: ASTBitCodes.h:1875
clang::CXXTypeidExpr
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:839
clang::CXXUnresolvedConstructExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: ExprCXX.h:3478
clang::UnresolvedSetIterator
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
clang::concepts::Requirement::SubstitutionDiagnostic
Definition: ExprConcepts.h:161
clang::serialization::EXPR_OBJC_MESSAGE_EXPR
@ EXPR_OBJC_MESSAGE_EXPR
An ObjCMessageExpr record.
Definition: ASTBitCodes.h:1748
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:475
clang::CXXFunctionalCastExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: ExprCXX.h:1769
clang::serialization::STMT_COMPOUND
@ STMT_COMPOUND
A CompoundStmt record.
Definition: ASTBitCodes.h:1529
clang::OverloadExpr::hasTemplateKWAndArgsInfo
bool hasTemplateKWAndArgsInfo() const
Definition: ExprCXX.h:2924
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:2478
clang::ParmVarDecl
Represents a parameter to a function.
Definition: Decl.h:1665
clang::Stmt::ConstantExprBits
ConstantExprBitfields ConstantExprBits
Definition: Stmt.h:1023
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:4480
AttrIterator.h
clang::Stmt::StringLiteralBits
StringLiteralBitfields StringLiteralBits
Definition: Stmt.h:1027
clang::ASTRecordReader::readSourceLocation
SourceLocation readSourceLocation()
Read a source location, advancing Idx.
Definition: ASTRecordReader.h:274
clang::serialization::STMT_CONTINUE
@ STMT_CONTINUE
A ContinueStmt record.
Definition: ASTBitCodes.h:1565
clang::VAArgExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: Expr.h:4660
clang::ConceptSpecializationExpr::setTemplateArguments
void setTemplateArguments(ArrayRef< TemplateArgument > Converted)
Set new template arguments for this concept specialization.
Definition: ExprConcepts.cpp:64
clang::OMPCancellationPointDirective::CreateEmpty
static OMPCancellationPointDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:778
clang::CXXNewExpr
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
Definition: ExprCXX.h:2139
clang::IfStmt
IfStmt - This represents an if/then/else.
Definition: Stmt.h:1904
clang::ExprObjectKind
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
Definition: Specifiers.h:134
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:6412
clang::serialization::EXPR_STMT
@ EXPR_STMT
A StmtExpr record.
Definition: ASTBitCodes.h:1685
clang::OMPIteratorExpr::CreateEmpty
static OMPIteratorExpr * CreateEmpty(const ASTContext &Context, unsigned NumIterators)
Definition: Expr.cpp:4977
clang::serialization::EXPR_CXX_DELETE
@ EXPR_CXX_DELETE
Definition: ASTBitCodes.h:1853
clang::CapturedRegionKind
CapturedRegionKind
The different kinds of captured statement.
Definition: CapturedStmt.h:16
clang::GotoStmt
GotoStmt - This represents a direct goto.
Definition: Stmt.h:2605
clang::InitListExpr
Describes an C or C++ initializer list.
Definition: Expr.h:4786
distance
float __ovld __cnfn distance(float p0, float p1)
Returns the distance between p0 and p1.
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:1844
clang::serialization::EXPR_CXX_PSEUDO_DESTRUCTOR
@ EXPR_CXX_PSEUDO_DESTRUCTOR
Definition: ASTBitCodes.h:1854
clang::Stmt::CXXScalarValueInitExprBits
CXXScalarValueInitExprBitfields CXXScalarValueInitExprBits
Definition: Stmt.h:1054
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:762
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:1941
clang::CompoundAssignOperator::setComputationLHSType
void setComputationLHSType(QualType T)
Definition: Expr.h:4085
clang::serialization::STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE
@ STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1913
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:1329
clang::serialization::STMT_OMP_ORDERED_DIRECTIVE
@ STMT_OMP_ORDERED_DIRECTIVE
Definition: ASTBitCodes.h:1923
clang::serialization::EXPR_CXX_SCALAR_VALUE_INIT
@ EXPR_CXX_SCALAR_VALUE_INIT
Definition: ASTBitCodes.h:1851
clang::UnaryOperator
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Definition: Expr.h:2157
clang::serialization::EXPR_ARRAY_INIT_INDEX
@ EXPR_ARRAY_INIT_INDEX
An ArrayInitIndexExpr record.
Definition: ASTBitCodes.h:1673
clang::serialization::STMT_OMP_MASKED_DIRECTIVE
@ STMT_OMP_MASKED_DIRECTIVE
Definition: ASTBitCodes.h:1959
clang::OffsetOfExpr::getNumExpressions
unsigned getNumExpressions() const
Definition: Expr.h:2516
clang::UnaryOperator::setOperatorLoc
void setOperatorLoc(SourceLocation L)
Definition: Expr.h:2209
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:1899
clang::ImplicitCastExpr::CreateEmpty
static ImplicitCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize, bool HasFPFeatures)
Definition: Expr.cpp:2019
clang::serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE
@ STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE
Definition: ASTBitCodes.h:1953
clang::serialization::EXPR_COAWAIT
@ EXPR_COAWAIT
Definition: ASTBitCodes.h:1971
clang::CoreturnStmt
Represents a 'co_return' statement in the C++ Coroutines TS.
Definition: StmtCXX.h:456
clang::Stmt::SourceLocExprBits
SourceLocExprBitfields SourceLocExprBits
Definition: Stmt.h:1040
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:4372
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:5416
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:1902
clang::Stmt::SubstNonTypeTemplateParmExprBits
SubstNonTypeTemplateParmExprBitfields SubstNonTypeTemplateParmExprBits
Definition: Stmt.h:1067
clang::serialization::EXPR_CXX_NOEXCEPT
@ EXPR_CXX_NOEXCEPT
Definition: ASTBitCodes.h:1865
clang::CompoundLiteralExpr::setInitializer
void setInitializer(Expr *E)
Definition: Expr.h:3428
clang::serialization::EXPR_CXX_DYNAMIC_CAST
@ EXPR_CXX_DYNAMIC_CAST
A CXXDynamicCastExpr record.
Definition: ASTBitCodes.h:1816
clang::ObjCMessageExpr::SuperClass
@ SuperClass
The receiver is a superclass.
Definition: ExprObjC.h:1094
clang::CastExpr::setCastKind
void setCastKind(CastKind K)
Definition: Expr.h:3519
clang::serialization::STMT_OMP_TARGET_SIMD_DIRECTIVE
@ STMT_OMP_TARGET_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1947
clang::CastExpr::getTrailingFPFeatures
FPOptionsOverride * getTrailingFPFeatures()
Return a pointer to the trailing FPOptions.
Definition: Expr.cpp:1977
clang::CXXUnresolvedConstructExpr::getNumArgs
unsigned getNumArgs() const
Retrieve the number of arguments.
Definition: ExprCXX.h:3486
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:1837
clang::serialization::EXPR_CXX_BOOL_LITERAL
@ EXPR_CXX_BOOL_LITERAL
A CXXBoolLiteralExpr record.
Definition: ASTBitCodes.h:1840
clang::ConceptSpecializationExpr::Satisfaction
ASTConstraintSatisfaction * Satisfaction
Information about the satisfaction of the named concept with the given arguments.
Definition: ExprConcepts.h:56
clang::CallExpr::setADLCallKind
void setADLCallKind(ADLCallKind V=UsesADL)
Definition: Expr.h:2952
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:476
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:2218
clang::RequiresExpr::Create
static RequiresExpr * Create(ASTContext &C, SourceLocation RequiresKWLoc, RequiresExprBodyDecl *Body, ArrayRef< ParmVarDecl * > LocalParameters, ArrayRef< concepts::Requirement * > Requirements, SourceLocation RBraceLoc)
Definition: ExprConcepts.cpp:194
clang::ObjCBoolLiteralExpr::setLocation
void setLocation(SourceLocation L)
Definition: ExprObjC.h:108
clang::Stmt::ExprWithCleanupsBits
ExprWithCleanupsBitfields ExprWithCleanupsBits
Definition: Stmt.h:1060
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:1103
clang::OMPTargetTeamsDistributeParallelForDirective
This represents '#pragma omp target teams distribute parallel for' combined directive.
Definition: StmtOpenMP.h:4829
clang::FixedPointLiteral::Create
static FixedPointLiteral * Create(const ASTContext &C, EmptyShell Empty)
Returns an empty fixed-point literal.
Definition: Expr.cpp:913
clang::ParenExpr::setLParen
void setLParen(SourceLocation Loc)
Definition: Expr.h:2130
clang::OpaqueValueExpr
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Definition: Expr.h:1129
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:3514
clang::SEHTryStmt
Definition: Stmt.h:3408
clang::CUDAKernelCallExpr::CreateEmpty
static CUDAKernelCallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty)
Definition: ExprCXX.cpp:1734
clang::CXXFoldExpr
Represents a folding of a pack over an operator.
Definition: ExprCXX.h:4574
clang::serialization::STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE
@ STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE
Definition: ASTBitCodes.h:1928
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:1038
clang::serialization::EXPR_CALL
@ EXPR_CALL
A CallExpr record.
Definition: ASTBitCodes.h:1631
clang::OMPTaskgroupDirective
This represents '#pragma omp taskgroup' directive.
Definition: StmtOpenMP.h:2576
clang::serialization::EXPR_OBJC_DICTIONARY_LITERAL
@ EXPR_OBJC_DICTIONARY_LITERAL
Definition: ASTBitCodes.h:1724
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:1775
clang::ConditionalOperator
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:4141
clang::CXXThrowExpr
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:1181
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:1935
clang::serialization::EXPR_DESIGNATED_INIT
@ EXPR_DESIGNATED_INIT
A DesignatedInitExpr record.
Definition: ASTBitCodes.h:1661
clang::serialization::EXPR_OBJC_PROTOCOL_EXPR
@ EXPR_OBJC_PROTOCOL_EXPR
An ObjCProtocolExpr record.
Definition: ASTBitCodes.h:1733
clang::serialization::EXPR_ADDR_LABEL
@ EXPR_ADDR_LABEL
An AddrLabelExpr record.
Definition: ASTBitCodes.h:1682
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:3994
clang::ASTStmtReader::VisitStmt
void VisitStmt(Stmt *S)
Definition: ASTReaderStmt.cpp:142
clang::CXXTemporaryObjectExpr
Represents a C++ functional cast expression that builds a temporary object.
Definition: ExprCXX.h:1797
clang::FunctionParmPackExpr
Represents a reference to a function parameter pack or init-capture pack that has been substituted bu...
Definition: ExprCXX.h:4380
clang::serialization::EXPR_OBJC_BOXED_EXPRESSION
@ EXPR_OBJC_BOXED_EXPRESSION
Definition: ASTBitCodes.h:1722
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:1058
clang::FixedPointLiteral
Definition: Expr.h:1531
clang::OMPTargetExitDataDirective
This represents '#pragma omp target exit data' directive.
Definition: StmtOpenMP.h:3109
clang::FloatingLiteral::getSemantics
const llvm::fltSemantics & getSemantics() const
Return the APFloat semantics this literal uses.
Definition: Expr.h:1669
clang::OMPExecutableDirective::Data
OMPChildren * Data
Data, associated with the directive.
Definition: StmtOpenMP.h:286
clang::ConstantExpr::RSK_APValue
@ RSK_APValue
Definition: Expr.h:1038
clang::OMPForSimdDirective
This represents '#pragma omp for simd' directive.
Definition: StmtOpenMP.h:1697
clang::ArraySubscriptExpr::setRBracketLoc
void setRBracketLoc(SourceLocation L)
Definition: Expr.h:2690
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:1846
clang::CXXDependentScopeMemberExpr::CreateEmpty
static CXXDependentScopeMemberExpr * CreateEmpty(const ASTContext &Ctx, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs, bool HasFirstQualifierFoundInScope)
Definition: ExprCXX.cpp:1425
clang::UnaryOperator::hasStoredFPFeatures
bool hasStoredFPFeatures() const
Is FPFeatures in Trailing Storage?
Definition: Expr.h:2300
TemplateBase.h
clang::IntegerLiteral
Definition: Expr.h:1488
clang::PseudoObjectExpr::Create
static PseudoObjectExpr * Create(const ASTContext &Context, Expr *syntactic, ArrayRef< Expr * > semantic, unsigned resultIndex)
Definition: Expr.cpp:4600
clang::serialization::STMT_OMP_UNROLL_DIRECTIVE
@ STMT_OMP_UNROLL_DIRECTIVE
Definition: ASTBitCodes.h:1904
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:2543
clang::FloatingLiteral
Definition: Expr.h:1633
clang::serialization::EXPR_CXX_CONSTRUCT
@ EXPR_CXX_CONSTRUCT
A CXXConstructExpr record.
Definition: ASTBitCodes.h:1804
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:1921
clang::TemplateArgument::getKind
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:245
clang::AddrLabelExpr::setAmpAmpLoc
void setAmpAmpLoc(SourceLocation L)
Definition: Expr.h:4316
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:6790
clang::MemberExprNameQualifier
Extra data stored in some MemberExpr objects.
Definition: Expr.h:3150
clang::CompoundStmt
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:1399
clang::ConvertVectorExpr
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
Definition: Expr.h:4461
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:1858
clang::MSPropertySubscriptExpr
MS property subscript expression.
Definition: ExprCXX.h:994
clang::serialization::ModuleFile::DeclsCursor
llvm::BitstreamCursor DeclsCursor
DeclsCursor - This is a cursor to the start of the DECLTYPES_BLOCK block.
Definition: ModuleFile.h:431
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:1940
clang::OMPParallelMasterDirective
This represents '#pragma omp parallel master' directive.
Definition: StmtOpenMP.h:2231
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:3073
clang::RequiresExprBodyDecl
Represents the body of a requires-expression.
Definition: DeclCXX.h:1926
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:1903
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:1514
clang::TemplateArgumentListInfo
A convenient class for passing around template argument information.
Definition: TemplateBase.h:564
clang::CXXNewExpr::setOperatorNew
void setOperatorNew(FunctionDecl *D)
Definition: ExprCXX.h:2258
clang::serialization::EXPR_CXX_MEMBER_CALL
@ EXPR_CXX_MEMBER_CALL
A CXXMemberCallExpr record.
Definition: ASTBitCodes.h:1798
clang::serialization::STMT_OMP_TASKGROUP_DIRECTIVE
@ STMT_OMP_TASKGROUP_DIRECTIVE
Definition: ASTBitCodes.h:1932
clang::Decl::getAccess
AccessSpecifier getAccess() const
Definition: DeclBase.h:478
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:740
clang::CXXConstructExpr::CreateEmpty
static CXXConstructExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs)
Create an empty C++ construction expression.
Definition: ExprCXX.cpp:1047
clang::DependentCoawaitExpr
Represents a 'co_await' expression while the type of the promise is dependent.
Definition: ExprCXX.h:4800
clang::SizeOfPackExpr
Represents an expression that computes the length of a parameter pack.
Definition: ExprCXX.h:4127
clang::serialization::STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE
@ STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE
Definition: ASTBitCodes.h:1915
clang::CXXBindTemporaryExpr
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1412
clang::ShuffleVectorExpr::setExprs
void setExprs(const ASTContext &C, ArrayRef< Expr * > Exprs)
Definition: Expr.cpp:4170
clang::OverloadExpr::getNumDecls
unsigned getNumDecls() const
Gets the number of declarations in the unresolved set.
Definition: ExprCXX.h:2983
clang::serialization::EXPR_ARRAY_SUBSCRIPT
@ EXPR_ARRAY_SUBSCRIPT
An ArraySubscriptExpr record.
Definition: ASTBitCodes.h:1625
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:3803
clang::ObjCSubscriptRefExpr::setKeyExpr
void setKeyExpr(Stmt *S)
Definition: ExprObjC.h:884
clang::InitListExpr::setRBraceLoc
void setRBraceLoc(SourceLocation Loc)
Definition: Expr.h:4938
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:1345
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:3964
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:1508
clang::TemplateArgumentListInfo::addArgument
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:604
clang::OMPTeamsDirective
This represents '#pragma omp teams' directive.
Definition: StmtOpenMP.h:3338
clang::VAArgExpr::setIsMicrosoftABI
void setIsMicrosoftABI(bool IsMS)
Definition: Expr.h:4651
clang::XRayInstrKind::None
constexpr XRayInstrMask None
Definition: XRayInstr.h:38
clang::serialization::STMT_SEH_LEAVE
@ STMT_SEH_LEAVE
Definition: ASTBitCodes.h:1893
clang::LambdaExpr
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1865
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:1681
clang::ObjCAtThrowStmt
Represents Objective-C's @throw statement.
Definition: StmtObjC.h:357
clang::CXXThisExpr::setImplicit
void setImplicit(bool I)
Definition: ExprCXX.h:1160
OperatorKinds.h
clang::Stmt::PredefinedExprBits
PredefinedExprBitfields PredefinedExprBits
Definition: Stmt.h:1024
clang::SourceRange::getEnd
SourceLocation getEnd() const
Definition: SourceLocation.h:222
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:89
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:110
clang::Stmt::CXXDefaultInitExprBits
CXXDefaultInitExprBitfields CXXDefaultInitExprBits
Definition: Stmt.h:1053
clang::serialization::STMT_ATTRIBUTED
@ STMT_ATTRIBUTED
An AttributedStmt record.
Definition: ASTBitCodes.h:1541
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:5212
clang::MaterializeTemporaryExpr
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Definition: ExprCXX.h:4462
clang::serialization::EXPR_DESIGNATED_INIT_UPDATE
@ EXPR_DESIGNATED_INIT_UPDATE
A DesignatedInitUpdateExpr record.
Definition: ASTBitCodes.h:1664
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:2083
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:212
clang::index::SymbolRole::Implicit
@ Implicit
clang::serialization::EXPR_CXX_TYPEID_EXPR
@ EXPR_CXX_TYPEID_EXPR
Definition: ASTBitCodes.h:1843
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:1813
clang::OMPMetaDirective
This represents '#pragma omp metadirective' directive.
Definition: StmtOpenMP.h:5434
NestedNameSpecifier.h
LangOptions.h
clang::serialization::EXPR_OBJC_AVAILABILITY_CHECK
@ EXPR_OBJC_AVAILABILITY_CHECK
An ObjCAvailabilityCheckExpr record.
Definition: ASTBitCodes.h:1781
clang::Stmt::MemberExprBits
MemberExprBitfields MemberExprBits
Definition: Stmt.h:1033
clang::CXXConstructExpr::setArg
void setArg(unsigned Arg, Expr *ArgExpr)
Set the specified argument.
Definition: ExprCXX.h:1621
clang::ImplicitCastExpr::setIsPartOfExplicitCast
void setIsPartOfExplicitCast(bool PartOfExplicitCast)
Definition: Expr.h:3652
clang::Stmt::StmtExprBits
StmtExprBitfields StmtExprBits
Definition: Stmt.h:1043
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:1903
clang::CallExpr::setArg
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
Definition: Expr.h:2999
clang::BinaryOperator::setRHS
void setRHS(Expr *E)
Definition: Expr.h:3855
clang::serialization::EXPR_CXX_BIND_TEMPORARY
@ EXPR_CXX_BIND_TEMPORARY
Definition: ASTBitCodes.h:1849
clang::concepts::NestedRequirement
A requires-expression requirement which is satisfied when a general constraint expression is satisfie...
Definition: ExprConcepts.h:407
TypeTraits.h
clang::Stmt::CXXConstructExprBits
CXXConstructExprBitfields CXXConstructExprBits
Definition: Stmt.h:1059
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:119
clang::BuiltinBitCastExpr
Represents a C++2a __builtin_bit_cast(T, v) expression.
Definition: ExprCXX.h:4875
clang::ExprWithCleanups::CleanupObject
llvm::PointerUnion< BlockDecl *, CompoundLiteralExpr * > CleanupObject
The type of objects that are kept in the cleanup.
Definition: ExprCXX.h:3352
clang::serialization::STMT_OMP_FOR_SIMD_DIRECTIVE
@ STMT_OMP_FOR_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1906
clang::serialization::EXPR_SOURCE_LOC
@ EXPR_SOURCE_LOC
A SourceLocExpr record.
Definition: ASTBitCodes.h:1694
clang::serialization::STMT_DO
@ STMT_DO
A DoStmt record.
Definition: ASTBitCodes.h:1553
clang::TemplateArgument
Represents a template argument.
Definition: TemplateBase.h:62
clang::CharacterLiteral::setKind
void setKind(CharacterKind kind)
Definition: Expr.h:1615
OpenMPKinds.h
clang::serialization::EXPR_IMPLICIT_CAST
@ EXPR_IMPLICIT_CAST
An ImplicitCastExpr record.
Definition: ASTBitCodes.h:1646
clang::concepts::Requirement
A static requirement that can be used in a requires-expression to check properties of types and expre...
Definition: ExprConcepts.h:149
clang::OMPDistributeParallelForSimdDirective
This represents '#pragma omp distribute parallel for simd' composite directive.
Definition: StmtOpenMP.h:4151
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:1083
clang::ASTStmtReader
Definition: ASTReaderStmt.cpp:71
clang::CastExpr::path_begin
path_iterator path_begin()
Definition: Expr.h:3544
clang::ObjCMessageExpr::setSelector
void setSelector(Selector S)
Definition: ExprObjC.h:1341
clang::serialization::STMT_OMP_PARALLEL_DIRECTIVE
@ STMT_OMP_PARALLEL_DIRECTIVE
Definition: ASTBitCodes.h:1901
clang::DesignatedInitUpdateExpr::setBase
void setBase(Expr *Base)
Definition: Expr.h:5382
clang::ForStmt
ForStmt - This represents a 'for (init;cond;inc)' stmt.
Definition: Stmt.h:2534
clang::ObjCAvailabilityCheckExpr
A runtime availability query.
Definition: ExprObjC.h:1686
clang::CXXFunctionalCastExpr::setLParenLoc
void setLParenLoc(SourceLocation L)
Definition: ExprCXX.h:1767
clang::serialization::STMT_OBJC_AT_TRY
@ STMT_OBJC_AT_TRY
An ObjCAtTryStmt record.
Definition: ASTBitCodes.h:1766
clang::OMPDepobjDirective
This represents '#pragma omp depobj' directive.
Definition: StmtOpenMP.h:2695
clang::CastExpr::hasStoredFPFeatures
bool hasStoredFPFeatures() const
Definition: Expr.h:3561
clang::ASTRecordReader::readString
std::string readString()
Read a string, advancing Idx.
Definition: ASTRecordReader.h:309
clang::serialization::STMT_OBJC_FOR_COLLECTION
@ STMT_OBJC_FOR_COLLECTION
An ObjCForCollectionStmt record.
Definition: ASTBitCodes.h:1757
clang::CXXNullPtrLiteralExpr::setLocation
void setLocation(SourceLocation L)
Definition: ExprCXX.h:774
clang::serialization::STMT_CXX_CATCH
@ STMT_CXX_CATCH
A CXXCatchStmt record.
Definition: ASTBitCodes.h:1786
clang::ASTTemplateKWAndArgsInfo::initializeFrom
void initializeFrom(SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &List, TemplateArgumentLoc *OutArgArray)
Definition: TemplateBase.cpp:629
clang::Stmt::CXXRewrittenBinaryOperatorBits
CXXRewrittenBinaryOperatorBitfields CXXRewrittenBinaryOperatorBits
Definition: Stmt.h:1047
clang::PseudoObjectExpr
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:6095
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:5277
clang::serialization::EXPR_ASTYPE
@ EXPR_ASTYPE
Definition: ASTBitCodes.h:1886
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:883
clang::InitListExpr::setLBraceLoc
void setLBraceLoc(SourceLocation Loc)
Definition: Expr.h:4936
clang::UnaryOperator::setOpcode
void setOpcode(Opcode Opc)
Definition: Expr.h:2202
clang::index::SymbolKind::Field
@ Field
clang::ChooseExpr::setRHS
void setRHS(Expr *E)
Definition: Expr.h:4565
clang::BinaryConditionalOperator
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition: Expr.h:4203
clang::CXXNewExpr::raw_arg_end
raw_arg_iterator raw_arg_end()
Definition: ExprCXX.h:2368
clang::ParenListExpr::getNumExprs
unsigned getNumExprs() const
Return the number of expressions in this paren list.
Definition: Expr.h:5558
clang::serialization::EXPR_BUILTIN_BIT_CAST
@ EXPR_BUILTIN_BIT_CAST
A BuiltinBitCastExpr record.
Definition: ASTBitCodes.h:1831
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:2270
clang::CapturedStmt::VariableCaptureKind
VariableCaptureKind
The different capture forms: by 'this', by reference, capture for variable-length array type etc.
Definition: Stmt.h:3504
clang::DeclRefExpr::getDecl
ValueDecl * getDecl()
Definition: Expr.h:1289
clang::TemplateArgumentLoc
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:458
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:1816
Type.h
clang::ExtVectorElementExpr::setAccessor
void setAccessor(IdentifierInfo *II)
Definition: Expr.h:5927
clang::Stmt::RequiresExprBits
RequiresExprBitfields RequiresExprBits
Definition: Stmt.h:1069
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:877
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:1879
clang::ConceptSpecializationExpr::Create
static ConceptSpecializationExpr * Create(const ASTContext &C, NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo, NamedDecl *FoundDecl, ConceptDecl *NamedConcept, const ASTTemplateArgumentListInfo *ArgsAsWritten, ArrayRef< TemplateArgument > ConvertedArgs, const ConstraintSatisfaction *Satisfaction)
Definition: ExprConcepts.cpp:72
clang::ImplicitValueInitExpr
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:5505
bool
#define bool
Definition: stdbool.h:15
clang::CXXBindTemporaryExpr::setSubExpr
void setSubExpr(Expr *E)
Definition: ExprCXX.h:1436
clang::serialization::STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE
@ STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1946
clang::TemplateArgumentListInfo::setLAngleLoc
void setLAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:583
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:3767
clang::serialization::DesignatorTypes
DesignatorTypes
The kinds of designators that can occur in a DesignatedInitExpr.
Definition: ASTBitCodes.h:1984
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:2166
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:876
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:2376
clang::OffsetOfExpr::getNumComponents
unsigned getNumComponents() const
Definition: Expr.h:2497
clang::FloatingLiteral::setLocation
void setLocation(SourceLocation L)
Definition: Expr.h:1689
clang::OffsetOfExpr::setTypeSourceInfo
void setTypeSourceInfo(TypeSourceInfo *tsi)
Definition: Expr.h:2483
clang::CapturedStmt::CreateDeserialized
static CapturedStmt * CreateDeserialized(const ASTContext &Context, unsigned NumCaptures)
Definition: Stmt.cpp:1371
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:69
clang::StringLiteral
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1761
clang::serialization::STMT_CORETURN
@ STMT_CORETURN
Definition: ASTBitCodes.h:1970
clang::OMPTargetParallelDirective
This represents '#pragma omp target parallel' directive.
Definition: StmtOpenMP.h:3163
clang::serialization::STMT_OMP_CANCEL_DIRECTIVE
@ STMT_OMP_CANCEL_DIRECTIVE
Definition: ASTBitCodes.h:1934
clang::ExprWithCleanups
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
Definition: ExprCXX.h:3342
clang::serialization::STMT_OMP_TARGET_PARALLEL_DIRECTIVE
@ STMT_OMP_TARGET_PARALLEL_DIRECTIVE
Definition: ASTBitCodes.h:1929
clang::CapturedStmt
This captures a statement into a function.
Definition: Stmt.h:3500
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:2069
clang::serialization::STMT_OMP_SCAN_DIRECTIVE
@ STMT_OMP_SCAN_DIRECTIVE
Definition: ASTBitCodes.h:1922
clang::DesignatedInitExpr::setEqualOrColonLoc
void setEqualOrColonLoc(SourceLocation L)
Definition: Expr.h:5253
clang::serialization::EXPR_UNARY_OPERATOR
@ EXPR_UNARY_OPERATOR
A UnaryOperator record.
Definition: ASTBitCodes.h:1616
clang::ObjCSelectorExpr::setSelector
void setSelector(Selector S)
Definition: ExprObjC.h:469
clang::OpaqueValueExpr::setIsUnique
void setIsUnique(bool V)
Definition: Expr.h:1181
clang::ImaginaryLiteral::setSubExpr
void setSubExpr(Expr *E)
Definition: Expr.h:1726
clang::serialization::STMT_OMP_DISPATCH_DIRECTIVE
@ STMT_OMP_DISPATCH_DIRECTIVE
Definition: ASTBitCodes.h:1958
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:697
clang::serialization::EXPR_OMP_ARRAY_SHAPING
@ EXPR_OMP_ARRAY_SHAPING
Definition: ASTBitCodes.h:1961
clang::ObjCIvarRefExpr::setBase
void setBase(Expr *base)
Definition: ExprObjC.h:582
clang::CStyleCastExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: Expr.h:3770
clang::CXXTryStmt
CXXTryStmt - A C++ try block, including all handlers.
Definition: StmtCXX.h:68
clang::SwitchCase
Definition: Stmt.h:1522
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:1568
ExprCXX.h
clang::serialization::STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE
@ STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1945
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:1931
clang::FixedPointLiteral::setScale
void setScale(unsigned S)
Definition: Expr.h:1561
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:1203
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:1520
clang::CXXInheritedCtorInitExpr
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition: ExprCXX.h:1651
clang::CXXDefaultArgExpr
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:1241
clang::serialization::STMT_RETURN
@ STMT_RETURN
A ReturnStmt record.
Definition: ASTBitCodes.h:1571
clang::PackExpansionExpr
Represents a C++11 pack expansion that produces a sequence of expressions.
Definition: ExprCXX.h:4051
clang::CastExpr::path_size
unsigned path_size() const
Definition: Expr.h:3543
clang::concepts::TypeRequirement::SatisfactionStatus
SatisfactionStatus
Definition: ExprConcepts.h:205
clang::UnaryExprOrTypeTraitExpr::setArgument
void setArgument(Expr *E)
Definition: Expr.h:2601
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:964
clang::OMPCriticalDirective
This represents '#pragma omp critical' directive.
Definition: StmtOpenMP.h:1998
clang::DeclRefExpr::hasQualifier
bool hasQualifier() const
Determine whether this declaration reference was preceded by a C++ nested-name-specifier,...
Definition: Expr.h:1304
clang::AtomicExpr::AtomicOp
AtomicOp
Definition: Expr.h:6231
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:4282
DeclGroup.h
clang::CompoundLiteralExpr::setTypeSourceInfo
void setTypeSourceInfo(TypeSourceInfo *tinfo)
Definition: Expr.h:3439
clang::serialization::EXPR_OBJC_ISA
@ EXPR_OBJC_ISA
An ObjCIsa Expr record.
Definition: ASTBitCodes.h:1751
clang::ObjCIvarRefExpr::setLocation
void setLocation(SourceLocation L)
Definition: ExprObjC.h:590
clang::OMPMasterTaskLoopDirective
This represents '#pragma omp master taskloop' directive.
Definition: StmtOpenMP.h:3648
clang::serialization::EXPR_SYCL_UNIQUE_STABLE_NAME
@ EXPR_SYCL_UNIQUE_STABLE_NAME
Definition: ASTBitCodes.h:1979
clang::BlockExpr::setBlockDecl
void setBlockDecl(BlockDecl *BD)
Definition: Expr.h:5979
clang::concepts::Requirement::RK_Compound
@ RK_Compound
Definition: ExprConcepts.h:153
clang::ConstantExpr
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
Definition: Expr.h:1026
clang::serialization::EXPR_DECL_REF
@ EXPR_DECL_REF
A DeclRefExpr record.
Definition: ASTBitCodes.h:1592
clang::concepts::Requirement::RK_Simple
@ RK_Simple
Definition: ExprConcepts.h:153
clang::serialization::EXPR_MEMBER
@ EXPR_MEMBER
A MemberExpr record.
Definition: ASTBitCodes.h:1634
clang::serialization::EXPR_REQUIRES
@ EXPR_REQUIRES
Definition: ASTBitCodes.h:1880
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:4414
clang::serialization::COK_Block
@ COK_Block
Definition: ASTBitCodes.h:2009
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:956
clang::OffsetOfNode
Helper class for OffsetOfExpr.
Definition: Expr.h:2334
clang::serialization::STMT_COROUTINE_BODY
@ STMT_COROUTINE_BODY
Definition: ASTBitCodes.h:1969
clang::serialization::EXPR_CXX_REWRITTEN_BINARY_OPERATOR
@ EXPR_CXX_REWRITTEN_BINARY_OPERATOR
A CXXRewrittenBinaryOperator record.
Definition: ASTBitCodes.h:1801
clang::ASTRecordReader::readDecl
Decl * readDecl()
Reads a declaration from the given position in a record in the given module, advancing Idx.
Definition: ASTRecordReader.h:192
clang::FullExpr::SubExpr
Stmt * SubExpr
Definition: Expr.h:1000
StmtObjC.h
clang::CompoundStmt::CreateEmpty
static CompoundStmt * CreateEmpty(const ASTContext &C, unsigned NumStmts)
Definition: Stmt.cpp:386
clang::ChooseExpr
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:4520
clang::serialization::EXPR_CXX_REINTERPRET_CAST
@ EXPR_CXX_REINTERPRET_CAST
A CXXReinterpretCastExpr record.
Definition: ASTBitCodes.h:1819
clang::ObjCIsaExpr::setOpLoc
void setOpLoc(SourceLocation L)
Definition: ExprObjC.h:1518
clang::ConstraintSatisfaction::IsSatisfied
bool IsSatisfied
Definition: ASTConcept.h:47
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:123
clang::SEHExceptStmt
Definition: Stmt.h:3329
clang::InitListExpr::sawArrayRangeDesignator
void sawArrayRangeDesignator(bool ARD=true)
Definition: Expr.h:4961
clang::OMPTaskyieldDirective::CreateEmpty
static OMPTaskyieldDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:726
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:1052
clang::serialization::EXPR_BLOCK
@ EXPR_BLOCK
BlockExpr.
Definition: ASTBitCodes.h:1703
clang::MatrixSubscriptExpr::setRBracketLoc
void setRBracketLoc(SourceLocation L)
Definition: Expr.h:2772
clang::ASTReader::ReadSubExpr
Expr * ReadSubExpr()
Reads a sub-expression operand during statement reading.
Definition: ASTReaderStmt.cpp:2657
clang::serialization::EXPR_CXX_THROW
@ EXPR_CXX_THROW
Definition: ASTBitCodes.h:1846
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:1954
clang::serialization::EXPR_CXX_FOLD
@ EXPR_CXX_FOLD
Definition: ASTBitCodes.h:1878
clang::serialization::STMT_INDIRECT_GOTO
@ STMT_INDIRECT_GOTO
An IndirectGotoStmt record.
Definition: ASTBitCodes.h:1562
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:2620
clang::GenericSelectionExpr::CreateEmpty
static GenericSelectionExpr * CreateEmpty(const ASTContext &Context, unsigned NumAssocs)
Create an empty generic selection expression for deserialization.
Definition: Expr.cpp:4258
clang::serialization::STMT_DEFAULT
@ STMT_DEFAULT
A DefaultStmt record.
Definition: ASTBitCodes.h:1535
clang::serialization::STMT_OMP_TARGET_DIRECTIVE
@ STMT_OMP_TARGET_DIRECTIVE
Definition: ASTBitCodes.h:1925
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:1858
clang::CharacterLiteral
Definition: Expr.h:1578
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:838
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:894
clang::BinaryOperator::setLHS
void setLHS(Expr *E)
Definition: Expr.h:3853
clang::CompoundAssignOperator::CreateEmpty
static CompoundAssignOperator * CreateEmpty(const ASTContext &C, bool hasFPFeatures)
Definition: Expr.cpp:4520
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:1591
clang::ChooseExpr::setIsConditionTrue
void setIsConditionTrue(bool isTrue)
Definition: Expr.h:4548
clang::serialization::EXPR_CXX_EXPRESSION_TRAIT
@ EXPR_CXX_EXPRESSION_TRAIT
Definition: ASTBitCodes.h:1864
clang::AddrLabelExpr::setLabelLoc
void setLabelLoc(SourceLocation L)
Definition: Expr.h:4318
clang::serialization::STMT_OMP_DEPOBJ_DIRECTIVE
@ STMT_OMP_DEPOBJ_DIRECTIVE
Definition: ASTBitCodes.h:1921
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:1702
clang::GNUNullExpr::setTokenLocation
void setTokenLocation(SourceLocation L)
Definition: Expr.h:4610
clang::serialization::EXPR_PAREN_LIST
@ EXPR_PAREN_LIST
A ParenListExpr record.
Definition: ASTBitCodes.h:1613
clang::OMPCancelDirective
This represents '#pragma omp cancel' directive.
Definition: StmtOpenMP.h:3449
clang::CompoundLiteralExpr
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:3403
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:1735
clang::serialization::EXPR_SIZEOF_ALIGN_OF
@ EXPR_SIZEOF_ALIGN_OF
A SizefAlignOfExpr record.
Definition: ASTBitCodes.h:1622
clang::MatrixSubscriptExpr::setRowIdx
void setRowIdx(Expr *E)
Definition: Expr.h:2749
ASTBitCodes.h
clang::serialization::EXPR_SIZEOF_PACK
@ EXPR_SIZEOF_PACK
Definition: ASTBitCodes.h:1873
clang::OMPSectionsDirective
This represents '#pragma omp sections' directive.
Definition: StmtOpenMP.h:1760
clang::OffsetOfNode::Kind
Kind
The kind of offsetof node we have.
Definition: Expr.h:2337
clang::AccessSpecifier
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:108
clang::serialization::EXPR_FUNCTION_PARM_PACK
@ EXPR_FUNCTION_PARM_PACK
Definition: ASTBitCodes.h:1876
clang::OMPTargetTeamsDistributeParallelForSimdDirective
This represents '#pragma omp target teams distribute parallel for simd' combined directive.
Definition: StmtOpenMP.h:4927
clang::CStyleCastExpr
CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr....
Definition: Expr.h:3731
clang::APIntStorage::setValue
void setValue(const ASTContext &C, const llvm::APInt &Val)
Definition: Expr.h:1473
clang::CallExpr::ADLCallKind
ADLCallKind
Definition: Expr.h:2851
clang::CallExpr::setCallee
void setCallee(Expr *F)
Definition: Expr.h:2947
clang::serialization::EXPR_MATRIX_SUBSCRIPT
@ EXPR_MATRIX_SUBSCRIPT
An MatrixSubscriptExpr record.
Definition: ASTBitCodes.h:1628
clang::Stmt::CXXDependentScopeMemberExprBits
CXXDependentScopeMemberExprBitfields CXXDependentScopeMemberExprBits
Definition: Stmt.h:1062
clang::GCCAsmStmt
This represents a GCC inline-assembly statement extension.
Definition: Stmt.h:3002
clang::OverloadExpr::getNumTemplateArgs
unsigned getNumTemplateArgs() const
Definition: ExprCXX.h:3039
clang::serialization::EXPR_CXX_OPERATOR_CALL
@ EXPR_CXX_OPERATOR_CALL
A CXXOperatorCallExpr record.
Definition: ASTBitCodes.h:1795
clang::CStyleCastExpr::CreateEmpty
static CStyleCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize, bool HasFPFeatures)
Definition: Expr.cpp:2046
SourceLocation.h
clang::StringLiteral::getKind
StringKind getKind() const
Definition: Expr.h:1876
clang::serialization::STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE
@ STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE
Definition: ASTBitCodes.h:1927
clang::OMPFlushDirective
This represents '#pragma omp flush' directive.
Definition: StmtOpenMP.h:2643
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:2843
clang::serialization::EXPR_BINARY_OPERATOR
@ EXPR_BINARY_OPERATOR
A BinaryOperator record.
Definition: ASTBitCodes.h:1637
clang::OMPTargetEnterDataDirective
This represents '#pragma omp target enter data' directive.
Definition: StmtOpenMP.h:3054
clang::ConceptReference::NestedNameSpec
NestedNameSpecifierLoc NestedNameSpec
Definition: ASTConcept.h:103
clang::DesignatedInitUpdateExpr
Definition: Expr.h:5362
clang::serialization::STMT_OMP_FLUSH_DIRECTIVE
@ STMT_OMP_FLUSH_DIRECTIVE
Definition: ASTBitCodes.h:1920
readConstraintSatisfaction
static ConstraintSatisfaction readConstraintSatisfaction(ASTRecordReader &Record)
Definition: ASTReaderStmt.cpp:787
clang::serialization::STMT_SEH_TRY
@ STMT_SEH_TRY
Definition: ASTBitCodes.h:1896
clang::serialization::EXPR_CXX_NULL_PTR_LITERAL
@ EXPR_CXX_NULL_PTR_LITERAL
Definition: ASTBitCodes.h:1842
clang::OffsetOfExpr::setIndexExpr
void setIndexExpr(unsigned Idx, Expr *E)
Definition: Expr.h:2511
clang::CXXUuidofExpr::setSourceRange
void setSourceRange(SourceRange R)
Definition: ExprCXX.h:1107
clang::ParenExpr::setSubExpr
void setSubExpr(Expr *E)
Definition: Expr.h:2123
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:5265
clang::serialization::DESIG_ARRAY
@ DESIG_ARRAY
Array designator.
Definition: ASTBitCodes.h:1993
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:972
clang::OMPIteratorHelperData::Upper
Expr * Upper
Normalized upper bound.
Definition: ExprOpenMP.h:240
clang::DesignatedInitExpr::setGNUSyntax
void setGNUSyntax(bool GNU)
Definition: Expr.h:5262
clang::serialization::STMT_IF
@ STMT_IF
An IfStmt record.
Definition: ASTBitCodes.h:1544
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:2004
clang::ASTRecordReader::readSourceRange
SourceRange readSourceRange()
Read a source range, advancing Idx.
Definition: ASTRecordReader.h:279
clang::OMPDistributeDirective
This represents '#pragma omp distribute' directive.
Definition: StmtOpenMP.h:3933
clang::serialization::DESIG_FIELD_NAME
@ DESIG_FIELD_NAME
Field designator where only the field name is known.
Definition: ASTBitCodes.h:1986
clang::concepts::TypeRequirement
A requires-expression requirement which queries the existence of a type name or type template special...
Definition: ExprConcepts.h:203
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:2065
clang::serialization::STMT_OMP_TASKYIELD_DIRECTIVE
@ STMT_OMP_TASKYIELD_DIRECTIVE
Definition: ASTBitCodes.h:1917
clang::ValueDecl
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:676
clang::OMPSingleDirective
This represents '#pragma omp single' directive.
Definition: StmtOpenMP.h:1899
clang::serialization::STMT_OBJC_CATCH
@ STMT_OBJC_CATCH
An ObjCAtCatchStmt record.
Definition: ASTBitCodes.h:1760
clang::ParenExpr
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:2106
clang::UnaryOperator::setSubExpr
void setSubExpr(Expr *E)
Definition: Expr.h:2205
clang::CoyieldExpr
Represents a 'co_yield' expression.
Definition: ExprCXX.h:4849
clang::serialization::EXPR_CXX_ADDRSPACE_CAST
@ EXPR_CXX_ADDRSPACE_CAST
A CXXAddrspaceCastExpr record.
Definition: ASTBitCodes.h:1825
clang::serialization::STMT_CXX_FOR_RANGE
@ STMT_CXX_FOR_RANGE
A CXXForRangeStmt record.
Definition: ASTBitCodes.h:1792
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:2973
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:1856
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:1754
clang::DesignatedInitExpr::setDesignators
void setDesignators(const ASTContext &C, const Designator *Desigs, unsigned NumDesigs)
Definition: Expr.cpp:4331
clang::OMPBarrierDirective::CreateEmpty
static OMPBarrierDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:737
clang::CXXDeleteExpr
Represents a delete expression for memory deallocation and destructor calls, e.g.
Definition: ExprCXX.h:2398
Begin
SourceLocation Begin
Definition: USRLocFinder.cpp:165
clang::CXXTemporaryObjectExpr::CreateEmpty
static CXXTemporaryObjectExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs)
Definition: ExprCXX.cpp:1013
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:5965
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:1283
clang::StmtExpr
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition: Expr.h:4345
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:3509
Value
Value
Definition: UninitializedValues.cpp:102
clang::MSPropertySubscriptExpr::setRBracketLoc
void setRBracketLoc(SourceLocation L)
Definition: ExprCXX.h:1032
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:89
clang::serialization::EXPR_INIT_LIST
@ EXPR_INIT_LIST
An InitListExpr record.
Definition: ASTBitCodes.h:1658
clang::CXXTypeidExpr::isTypeOperand
bool isTypeOperand() const
Definition: ExprCXX.h:875
clang::serialization::STMT_OMP_INTEROP_DIRECTIVE
@ STMT_OMP_INTEROP_DIRECTIVE
Definition: ASTBitCodes.h:1957
clang::OffsetOfNode::Base
@ Base
An implicit indirection through a C++ base class, when the field found is in a base class.
Definition: Expr.h:2346
OpenMPClause.h
clang::serialization::EXPR_CXX_CONST_CAST
@ EXPR_CXX_CONST_CAST
A CXXConstCastExpr record.
Definition: ASTBitCodes.h:1822
clang::AddrLabelExpr
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition: Expr.h:4300
clang::OMPArrayShapingExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: ExprOpenMP.h:196
clang::ParenExpr::setRParen
void setRParen(SourceLocation Loc)
Definition: Expr.h:2134
clang::CXXFunctionalCastExpr
Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr....
Definition: ExprCXX.h:1726
clang::DeclGroupRef
Definition: DeclGroup.h:51
clang::DesignatedInitExpr::Designator
Represents a single C99 designator.
Definition: Expr.h:5099
clang::FloatingLiteral::Create
static FloatingLiteral * Create(const ASTContext &C, const llvm::APFloat &V, bool isexact, QualType Type, SourceLocation L)
Definition: Expr.cpp:1014
clang::CharacterLiteral::setValue
void setValue(unsigned Val)
Definition: Expr.h:1616
clang::serialization::EXPR_NO_INIT
@ EXPR_NO_INIT
An NoInitExpr record.
Definition: ASTBitCodes.h:1667
clang::StmtExpr::setLParenLoc
void setLParenLoc(SourceLocation L)
Definition: Expr.h:4370
clang::ArraySubscriptExpr
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2639
clang::CXXUuidofExpr
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Definition: ExprCXX.h:1056
clang::DependentScopeDeclRefExpr
A qualified reference to a name whose declaration cannot yet be resolved.
Definition: ExprCXX.h:3191
clang::DoStmt
DoStmt - This represents a 'do/while' stmt.
Definition: Stmt.h:2478
clang::CXXNewExpr::setOperatorDelete
void setOperatorDelete(FunctionDecl *D)
Definition: ExprCXX.h:2260
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:1145
clang::serialization::EXPR_VA_ARG
@ EXPR_VA_ARG
A VAArgExpr record.
Definition: ASTBitCodes.h:1679
clang::AddrLabelExpr::setLabel
void setLabel(LabelDecl *L)
Definition: Expr.h:4324
clang::VAArgExpr::setSubExpr
void setSubExpr(Expr *E)
Definition: Expr.h:4647
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:1352
LLVM.h
clang::CXXNullPtrLiteralExpr
The null pointer literal (C++11 [lex.nullptr])
Definition: ExprCXX.h:759
clang::PredefinedExpr::setLocation
void setLocation(SourceLocation L)
Definition: Expr.h:2006
clang::ExtVectorElementExpr::setAccessorLoc
void setAccessorLoc(SourceLocation L)
Definition: Expr.h:5930
clang::CoroutineBodyStmt
Represents the body of a coroutine.
Definition: StmtCXX.h:317
clang::OffsetOfNode::Field
@ Field
A field.
Definition: Expr.h:2341
clang::concepts::ExprRequirement::SatisfactionStatus
SatisfactionStatus
Definition: ExprConcepts.h:260
clang::serialization::STMT_OMP_TASKWAIT_DIRECTIVE
@ STMT_OMP_TASKWAIT_DIRECTIVE
Definition: ASTBitCodes.h:1919
clang::serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE
@ STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1944
clang::Stmt::UnresolvedMemberExprBits
UnresolvedMemberExprBitfields UnresolvedMemberExprBits
Definition: Stmt.h:1065
clang::CoawaitExpr
Represents a 'co_await' expression.
Definition: ExprCXX.h:4764
clang::UnaryOperatorKind
UnaryOperatorKind
Definition: OperationKinds.h:30
clang::BreakStmt
BreakStmt - This represents a break.
Definition: Stmt.h:2723
clang::serialization::EXPR_OBJC_ENCODE
@ EXPR_OBJC_ENCODE
An ObjCEncodeExpr record.
Definition: ASTBitCodes.h:1727
clang::ShuffleVectorExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: Expr.h:4415
clang::serialization::EXPR_OBJC_BRIDGED_CAST
@ EXPR_OBJC_BRIDGED_CAST
Definition: ASTBitCodes.h:1965
clang::concepts::ExprRequirement::SS_ExprSubstitutionFailure
@ SS_ExprSubstitutionFailure
Definition: ExprConcepts.h:262
clang::OverloadExpr
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr.
Definition: ExprCXX.h:2880
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:2030
clang::serialization::EXPR_OBJC_IVAR_REF_EXPR
@ EXPR_OBJC_IVAR_REF_EXPR
An ObjCIvarRefExpr record.
Definition: ASTBitCodes.h:1736
clang::serialization::STMT_STOP
@ STMT_STOP
A marker record that indicates that we are at the end of an expression.
Definition: ASTBitCodes.h:1517
clang::OMPCancellationPointDirective
This represents '#pragma omp cancellation point' directive.
Definition: StmtOpenMP.h:3391
clang::OMPDispatchDirective
This represents '#pragma omp dispatch' directive.
Definition: StmtOpenMP.h:5318
clang::CXXDependentScopeMemberExpr
Represents a C++ member access expression where the actual member referenced could not be resolved be...
Definition: ExprCXX.h:3550
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:1909
clang::serialization::EXPR_OBJC_KVC_REF_EXPR
@ EXPR_OBJC_KVC_REF_EXPR
UNUSED.
Definition: ASTBitCodes.h:1745
clang::ObjCIvarRefExpr::setIsFreeIvar
void setIsFreeIvar(bool A)
Definition: ExprObjC.h:587
clang::RecoveryExpr::CreateEmpty
static RecoveryExpr * CreateEmpty(ASTContext &Ctx, unsigned NumSubExprs)
Definition: Expr.cpp:4801
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:1634
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:1103
clang::ASTStmtReader::ASTStmtReader
ASTStmtReader(ASTRecordReader &Record, llvm::BitstreamCursor &Cursor)
Definition: ASTReaderStmt.cpp:101
clang::CompoundAssignOperator
CompoundAssignOperator - For compound assignments (e.g.
Definition: Expr.h:4050
clang::BinaryOperatorKind
BinaryOperatorKind
Definition: OperationKinds.h:25
clang::serialization::EXPR_PAREN
@ EXPR_PAREN
A ParenExpr record.
Definition: ASTBitCodes.h:1610
clang::serialization::EXPR_CXX_DEFAULT_INIT
@ EXPR_CXX_DEFAULT_INIT
Definition: ASTBitCodes.h:1848
clang::ExprValueKind
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:117
clang::CXXNoexceptExpr
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
Definition: ExprCXX.h:3997
clang::serialization::STMT_SEH_EXCEPT
@ STMT_SEH_EXCEPT
Definition: ASTBitCodes.h:1894
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:3428
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:84
clang::DeclRefExpr::setLocation
void setLocation(SourceLocation L)
Definition: Expr.h:1298
clang::OMPTaskwaitDirective::CreateEmpty
static OMPTaskwaitDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:748
clang::serialization::STMT_GCCASM
@ STMT_GCCASM
A GCC-style AsmStmt record.
Definition: ASTBitCodes.h:1580
clang::OMPSectionDirective::setHasCancel
void setHasCancel(bool Has)
Set cancel state.
Definition: StmtOpenMP.h:1881
clang::ASTRecordReader::readExpr
Expr * readExpr()
Reads an expression.
Definition: ASTRecordReader.h:132
clang::OMPInteropDirective::CreateEmpty
static OMPInteropDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:2049
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:1942
clang::serialization::EXPR_CUDA_KERNEL_CALL
@ EXPR_CUDA_KERNEL_CALL
Definition: ASTBitCodes.h:1883
clang::StringLiteral::getCharByteWidth
unsigned getCharByteWidth() const
Definition: Expr.h:1874
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:893
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:1914
clang::Stmt::CXXDeleteExprBits
CXXDeleteExprBitfields CXXDeleteExprBits
Definition: Stmt.h:1056
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:1025
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:4324
clang::serialization::COK_CompoundLiteral
@ COK_CompoundLiteral
Definition: ASTBitCodes.h:2009
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:1236
clang::ObjCPropertyAttribute::Kind
Kind
Definition: DeclObjCCommon.h:22
clang::DeclStmt
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
Definition: Stmt.h:1292
clang::ContinueStmt
ContinueStmt - This represents a continue.
Definition: Stmt.h:2693
clang::ChooseExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: Expr.h:4571
clang::OffsetOfNode::Identifier
@ Identifier
A field in a dependent type, known only by its name.
Definition: Expr.h:2343
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:3068
clang::ConstantExpr::CreateEmpty
static ConstantExpr * CreateEmpty(const ASTContext &Context, ResultStorageKind StorageKind)
Definition: Expr.cpp:318
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:1677
clang::serialization::STMT_OMP_MASTER_TASKLOOP_DIRECTIVE
@ STMT_OMP_MASTER_TASKLOOP_DIRECTIVE
Definition: ASTBitCodes.h:1937
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:1142
clang::serialization::EXPR_COYIELD
@ EXPR_COYIELD
Definition: ASTBitCodes.h:1972
clang::ExtVectorElementExpr
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
Definition: Expr.h:5905
clang::OMPTeamsDistributeParallelForDirective
This represents '#pragma omp teams distribute parallel for' composite directive.
Definition: StmtOpenMP.h:4614
DeclarationName.h
clang::IfStatementKind
IfStatementKind
In an if statement, this denotes whether the 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:6358
clang::PredefinedExpr
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1953
clang::serialization::EXPR_PREDEFINED
@ EXPR_PREDEFINED
A PredefinedExpr record.
Definition: ASTBitCodes.h:1589
clang::serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT
@ EXPR_CXX_UNRESOLVED_CONSTRUCT
Definition: ASTBitCodes.h:1860
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:1939
clang::FPOptionsOverride::getFromOpaqueInt
static FPOptionsOverride getFromOpaqueInt(storage_type I)
Definition: LangOptions.h:658
clang::serialization::EXPR_ARRAY_TYPE_TRAIT
@ EXPR_ARRAY_TYPE_TRAIT
Definition: ASTBitCodes.h:1870
clang::OMPOrderedDirective::CreateEmpty
static OMPOrderedDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, bool IsStandalone, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:854
clang::SizeOfPackExpr::isPartiallySubstituted
bool isPartiallySubstituted() const
Determine whether this represents a partially-substituted sizeof...
Definition: ExprCXX.h:4215
clang::SEHFinallyStmt
Definition: Stmt.h:3373
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:1807
clang::ExtVectorElementExpr::setBase
void setBase(Expr *E)
Definition: Expr.h:5924
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:1877
clang::ConstantExpr::ResultStorageKind
ResultStorageKind
Describes the kind of result that can be tail-allocated.
Definition: Expr.h:1038
clang::serialization::EXPR_RECOVERY
@ EXPR_RECOVERY
A RecoveryExpr record.
Definition: ASTBitCodes.h:1715
clang::OMPArrayShapingExpr::setLParenLoc
void setLParenLoc(SourceLocation L)
Definition: ExprOpenMP.h:193
clang::OMPSimdDirective
This represents '#pragma omp simd' directive.
Definition: StmtOpenMP.h:1544
clang::UnaryExprOrTypeTraitExpr::setOperatorLoc
void setOperatorLoc(SourceLocation L)
Definition: Expr.h:2617
clang::CodeGen::CleanupKind
CleanupKind
Definition: EHScopeStack.h:77
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:584
clang::CompoundAssignOperator::setComputationResultType
void setComputationResultType(QualType T)
Definition: Expr.h:4088
clang::serialization::STMT_OMP_SECTIONS_DIRECTIVE
@ STMT_OMP_SECTIONS_DIRECTIVE
Definition: ASTBitCodes.h:1907
clang::serialization::EXPR_CXX_UUIDOF_EXPR
@ EXPR_CXX_UUIDOF_EXPR
Definition: ASTBitCodes.h:1891
clang::IntegerLiteral::setLocation
void setLocation(SourceLocation Location)
Definition: Expr.h:1516
clang::InitListExpr::setSyntacticForm
void setSyntacticForm(InitListExpr *Init)
Definition: Expr.h:4951
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:1640
clang::OMPTargetTeamsDirective
This represents '#pragma omp target teams' directive.
Definition: StmtOpenMP.h:4707
clang::serialization::EXPR_EXT_VECTOR_ELEMENT
@ EXPR_EXT_VECTOR_ELEMENT
An ExtVectorElementExpr record.
Definition: ASTBitCodes.h:1655
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::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:69
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:4055
clang::DefaultStmt
Definition: Stmt.h:1723
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:4498
clang::CXXNewExpr::isParenTypeId
bool isParenTypeId() const
Definition: ExprCXX.h:2292
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:1918
clang::ASTStmtReader::ReadTemplateKWAndArgsInfo
void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args, TemplateArgumentLoc *ArgsLocArray, unsigned NumTemplateArgs)
Read and initialize a ExplicitTemplateArgumentList structure.
Definition: ASTReaderStmt.cpp:130
clang::GenericSelectionExpr
Represents a C11 generic selection.
Definition: Expr.h:5623
clang::CXXScalarValueInitExpr
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type.
Definition: ExprCXX.h:2093
clang::serialization::EXPR_ATOMIC
@ EXPR_ATOMIC
An AtomicExpr record.
Definition: ASTBitCodes.h:1712
clang::ObjCIsaExpr
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
Definition: ExprObjC.h:1482
clang::serialization::STMT_OMP_ATOMIC_DIRECTIVE
@ STMT_OMP_ATOMIC_DIRECTIVE
Definition: ASTBitCodes.h:1924
clang::OMPMasterTaskLoopSimdDirective::CreateEmpty
static OMPMasterTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1191
clang::serialization::EXPR_OBJC_STRING_LITERAL
@ EXPR_OBJC_STRING_LITERAL
An ObjCStringLiteral record.
Definition: ASTBitCodes.h:1720
clang::serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM
@ EXPR_SUBST_NON_TYPE_TEMPLATE_PARM
Definition: ASTBitCodes.h:1874
clang::serialization::EXPR_FIXEDPOINT_LITERAL
@ EXPR_FIXEDPOINT_LITERAL
Definition: ASTBitCodes.h:1976
clang::CastExpr::setSubExpr
void setSubExpr(Expr *E)
Definition: Expr.h:3526
clang::Stmt::CXXThrowExprBits
CXXThrowExprBitfields CXXThrowExprBits
Definition: Stmt.h:1051
clang::serialization::EXPR_GNU_NULL
@ EXPR_GNU_NULL
A GNUNullExpr record.
Definition: ASTBitCodes.h:1691
clang::FixedPointLiteral::setLocation
void setLocation(SourceLocation Location)
Definition: Expr.h:1558
clang::ASTReader::ReadStmt
Stmt * ReadStmt(ModuleFile &F)
Reads a statement.
Definition: ASTReaderStmt.cpp:2639
clang::CXXBaseSpecifier
Represents a base class of a C++ class.
Definition: DeclCXX.h:147
clang::TypeSourceInfo
A container of type source information.
Definition: Type.h:6395
clang::CXXUuidofExpr::isTypeOperand
bool isTypeOperand() const
Definition: ExprCXX.h:1086
clang::CXXDependentScopeMemberExpr::getNumTemplateArgs
unsigned getNumTemplateArgs() const
Retrieve the number of template arguments provided as part of this template-id.
Definition: ExprCXX.h:3752
clang::NamedDecl::getDeclName
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:313
clang::OMPUnrollDirective
This represents the '#pragma omp unroll' loop transformation directive.
Definition: StmtOpenMP.h:5138
clang::SizeOfPackExpr::CreateDeserialized
static SizeOfPackExpr * CreateDeserialized(ASTContext &Context, unsigned NumPartialArgs)
Definition: ExprCXX.cpp:1566
clang::serialization::STMT_OMP_TASK_DIRECTIVE
@ STMT_OMP_TASK_DIRECTIVE
Definition: ASTBitCodes.h:1916
clang::serialization::EXPR_CXX_DEFAULT_ARG
@ EXPR_CXX_DEFAULT_ARG
Definition: ASTBitCodes.h:1847
clang::ParenListExpr::CreateEmpty
static ParenListExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumExprs)
Create an empty paren list.
Definition: Expr.cpp:4457
clang::serialization::STMT_LABEL
@ STMT_LABEL
A LabelStmt record.
Definition: ASTBitCodes.h:1538
clang::CXXThisExpr::setLocation
void setLocation(SourceLocation L)
Definition: ExprCXX.h:1154
clang::CXXNewExpr::hasInitializer
bool hasInitializer() const
Whether this new-expression has any initializer at all.
Definition: ExprCXX.h:2301
clang::CXXNamedCastExpr
Abstract class common to all of the C++ "named"/"keyword" casts.
Definition: ExprCXX.h:373
clang::OMPArraySectionExpr::setRBracketLoc
void setRBracketLoc(SourceLocation L)
Definition: ExprOpenMP.h:125
clang::ASTRecordReader::readDeclAs
T * readDeclAs()
Reads a declaration from the given position in the record, advancing Idx.
Definition: ASTRecordReader.h:205
clang::VAArgExpr::setWrittenTypeInfo
void setWrittenTypeInfo(TypeSourceInfo *TI)
Definition: Expr.h:4654
clang::serialization::STMT_OMP_SECTION_DIRECTIVE
@ STMT_OMP_SECTION_DIRECTIVE
Definition: ASTBitCodes.h:1908
clang::CallExpr::CreateEmpty
static CallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty)
Create an empty call expression, for deserialization.
Definition: Expr.cpp:1438
clang::OMPTargetDirective
This represents '#pragma omp target' directive.
Definition: StmtOpenMP.h:2946
clang::OMPTargetParallelForSimdDirective::CreateEmpty
static OMPTargetParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1552
clang::ObjCProtocolExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: ExprObjC.h:528
clang::ASTReader::ReadExpr
Expr * ReadExpr(ModuleFile &F)
Reads an expression.
Definition: ASTReaderStmt.cpp:2653
clang::ConstraintSatisfaction::SubstitutionDiagnostic
std::pair< SourceLocation, StringRef > SubstitutionDiagnostic
Definition: ASTConcept.h:44
clang::OMPTargetUpdateDirective
This represents '#pragma omp target update' directive.
Definition: StmtOpenMP.h:3999
clang::serialization::STMT_SEH_FINALLY
@ STMT_SEH_FINALLY
Definition: ASTBitCodes.h:1895
clang::StringLiteral::getLength
unsigned getLength() const
Definition: Expr.h:1873
clang::ObjCArrayLiteral::getElements
Expr ** getElements()
Retrieve elements of array of literals.
Definition: ExprObjC.h:221
clang::CXXUnresolvedConstructExpr::setLParenLoc
void setLParenLoc(SourceLocation L)
Definition: ExprCXX.h:3473
clang::ImplicitCastExpr
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3618
clang::VAArgExpr
Represents a call to the builtin function __builtin_va_arg.
Definition: Expr.h:4629
clang::OMPOrderedDirective
This represents '#pragma omp ordered' directive.
Definition: StmtOpenMP.h:2747
clang::SourceLocExpr
Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(), __builtin_FUNCTION(),...
Definition: Expr.h:4678
clang::serialization::STMT_OMP_MASTER_DIRECTIVE
@ STMT_OMP_MASTER_DIRECTIVE
Definition: ASTBitCodes.h:1910
clang::MemberExpr
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:3162
clang::serialization::EXPR_OPAQUE_VALUE
@ EXPR_OPAQUE_VALUE
Definition: ASTBitCodes.h:1867
clang::ConstraintSatisfaction
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
Definition: ASTConcept.h:29
clang::serialization::STMT_OMP_TARGET_TEAMS_DIRECTIVE
@ STMT_OMP_TARGET_TEAMS_DIRECTIVE
Definition: ASTBitCodes.h:1952
clang::CXXOperatorCallExpr::CreateEmpty
static CXXOperatorCallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty)
Definition: ExprCXX.cpp:573
clang::serialization::EXPR_OFFSETOF
@ EXPR_OFFSETOF
An OffsetOfExpr record.
Definition: ASTBitCodes.h:1619
clang::serialization::EXPR_OMP_ITERATOR
@ EXPR_OMP_ITERATOR
Definition: ASTBitCodes.h:1962
clang::OpenMPDirectiveKind
llvm::omp::Directive OpenMPDirectiveKind
OpenMP directives.
Definition: OpenMPKinds.h:24
clang::UnaryOperator::CreateEmpty
static UnaryOperator * CreateEmpty(const ASTContext &C, bool hasFPFeatures)
Definition: Expr.cpp:4542
clang::BinaryOperator::setHasStoredFPFeatures
void setHasStoredFPFeatures(bool B)
Set and fetch the bit that shows whether FPFeatures needs to be allocated in Trailing Storage.
Definition: Expr.h:3985
clang::serialization::STMT_OMP_PARALLEL_FOR_DIRECTIVE
@ STMT_OMP_PARALLEL_FOR_DIRECTIVE
Definition: ASTBitCodes.h:1912
clang::serialization::EXPR_CHOOSE
@ EXPR_CHOOSE
A ChooseExpr record.
Definition: ASTBitCodes.h:1688
clang::serialization::EXPR_LAMBDA
@ EXPR_LAMBDA
Definition: ASTBitCodes.h:1968
clang::ChooseExpr::setLHS
void setLHS(Expr *E)
Definition: Expr.h:4563
clang::serialization::STMT_OMP_CANCELLATION_POINT_DIRECTIVE
@ STMT_OMP_CANCELLATION_POINT_DIRECTIVE
Definition: ASTBitCodes.h:1933
clang::serialization::EXPR_CONSTANT
@ EXPR_CONSTANT
A constant expression context.
Definition: ASTBitCodes.h:1586
clang::ObjCMessageExpr::setMethodDecl
void setMethodDecl(ObjCMethodDecl *MD)
Definition: ExprObjC.h:1360
clang::OMPDistributeSimdDirective
This represents '#pragma omp distribute simd' composite directive.
Definition: StmtOpenMP.h:4216
clang::serialization::STMT_SWITCH
@ STMT_SWITCH
A SwitchStmt record.
Definition: ASTBitCodes.h:1547
clang::TemplateArgument::pack_size
unsigned pack_size() const
The number of template arguments in the given template argument pack.
Definition: TemplateBase.h:372
clang::serialization::EXPR_FLOATING_LITERAL
@ EXPR_FLOATING_LITERAL
A FloatingLiteral record.
Definition: ASTBitCodes.h:1598
clang::OMPTargetEnterDataDirective::CreateEmpty
static OMPTargetEnterDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:987
Stmt.h
clang::OverloadExpr::getTrailingTemplateArgumentLoc
TemplateArgumentLoc * getTrailingTemplateArgumentLoc()
Return the optional template arguments.
Definition: ExprCXX.h:3980
clang::BinaryOperator::setOperatorLoc
void setOperatorLoc(SourceLocation L)
Definition: Expr.h:3845
clang::serialization::STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE
@ STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE
Definition: ASTBitCodes.h:1951
clang::serialization::EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR
@ EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR
Definition: ASTBitCodes.h:1890
clang::OMPParallelMasterTaskLoopSimdDirective
This represents '#pragma omp parallel master taskloop simd' directive.
Definition: StmtOpenMP.h:3868
clang::ASTTemplateArgumentListInfo
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:613
clang::MatrixSubscriptExpr::setColumnIdx
void setColumnIdx(Expr *E)
Definition: Expr.h:2757
clang::GNUNullExpr
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
Definition: Expr.h:4595
clang::CXXStdInitializerListExpr
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
Definition: ExprCXX.h:791
clang::serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE
@ STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE
Definition: ASTBitCodes.h:1943
clang::concepts::Requirement::RK_Nested
@ RK_Nested
Definition: ExprConcepts.h:153