clang  8.0.0svn
StmtPrinter.cpp
Go to the documentation of this file.
1 //===- StmtPrinter.cpp - Printing implementation for Stmt ASTs ------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the Stmt::dumpPretty/Stmt::printPretty methods, which
11 // pretty print the AST back out to C code.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/Attr.h"
17 #include "clang/AST/Decl.h"
18 #include "clang/AST/DeclBase.h"
19 #include "clang/AST/DeclCXX.h"
20 #include "clang/AST/DeclObjC.h"
21 #include "clang/AST/DeclOpenMP.h"
22 #include "clang/AST/DeclTemplate.h"
23 #include "clang/AST/Expr.h"
24 #include "clang/AST/ExprCXX.h"
25 #include "clang/AST/ExprObjC.h"
26 #include "clang/AST/ExprOpenMP.h"
28 #include "clang/AST/OpenMPClause.h"
30 #include "clang/AST/Stmt.h"
31 #include "clang/AST/StmtCXX.h"
32 #include "clang/AST/StmtObjC.h"
33 #include "clang/AST/StmtOpenMP.h"
34 #include "clang/AST/StmtVisitor.h"
35 #include "clang/AST/TemplateBase.h"
36 #include "clang/AST/Type.h"
37 #include "clang/Basic/CharInfo.h"
40 #include "clang/Basic/LLVM.h"
41 #include "clang/Basic/Lambda.h"
45 #include "clang/Basic/TypeTraits.h"
46 #include "clang/Lex/Lexer.h"
47 #include "llvm/ADT/ArrayRef.h"
48 #include "llvm/ADT/SmallString.h"
49 #include "llvm/ADT/SmallVector.h"
50 #include "llvm/ADT/StringRef.h"
51 #include "llvm/Support/Casting.h"
52 #include "llvm/Support/Compiler.h"
53 #include "llvm/Support/ErrorHandling.h"
54 #include "llvm/Support/Format.h"
55 #include "llvm/Support/raw_ostream.h"
56 #include <cassert>
57 #include <string>
58 
59 using namespace clang;
60 
61 //===----------------------------------------------------------------------===//
62 // StmtPrinter Visitor
63 //===----------------------------------------------------------------------===//
64 
65 namespace {
66 
67  class StmtPrinter : public StmtVisitor<StmtPrinter> {
68  raw_ostream &OS;
69  unsigned IndentLevel;
70  PrinterHelper* Helper;
71  PrintingPolicy Policy;
72  std::string NL;
73  const ASTContext *Context;
74 
75  public:
76  StmtPrinter(raw_ostream &os, PrinterHelper *helper,
77  const PrintingPolicy &Policy, unsigned Indentation = 0,
78  StringRef NL = "\n",
79  const ASTContext *Context = nullptr)
80  : OS(os), IndentLevel(Indentation), Helper(helper), Policy(Policy),
81  NL(NL), Context(Context) {}
82 
83  void PrintStmt(Stmt *S) {
84  PrintStmt(S, Policy.Indentation);
85  }
86 
87  void PrintStmt(Stmt *S, int SubIndent) {
88  IndentLevel += SubIndent;
89  if (S && isa<Expr>(S)) {
90  // If this is an expr used in a stmt context, indent and newline it.
91  Indent();
92  Visit(S);
93  OS << ";" << NL;
94  } else if (S) {
95  Visit(S);
96  } else {
97  Indent() << "<<<NULL STATEMENT>>>" << NL;
98  }
99  IndentLevel -= SubIndent;
100  }
101 
102  void PrintInitStmt(Stmt *S, unsigned PrefixWidth) {
103  // FIXME: Cope better with odd prefix widths.
104  IndentLevel += (PrefixWidth + 1) / 2;
105  if (auto *DS = dyn_cast<DeclStmt>(S))
106  PrintRawDeclStmt(DS);
107  else
108  PrintExpr(cast<Expr>(S));
109  OS << "; ";
110  IndentLevel -= (PrefixWidth + 1) / 2;
111  }
112 
113  void PrintControlledStmt(Stmt *S) {
114  if (auto *CS = dyn_cast<CompoundStmt>(S)) {
115  OS << " ";
116  PrintRawCompoundStmt(CS);
117  OS << NL;
118  } else {
119  OS << NL;
120  PrintStmt(S);
121  }
122  }
123 
124  void PrintRawCompoundStmt(CompoundStmt *S);
125  void PrintRawDecl(Decl *D);
126  void PrintRawDeclStmt(const DeclStmt *S);
127  void PrintRawIfStmt(IfStmt *If);
128  void PrintRawCXXCatchStmt(CXXCatchStmt *Catch);
129  void PrintCallArgs(CallExpr *E);
130  void PrintRawSEHExceptHandler(SEHExceptStmt *S);
131  void PrintRawSEHFinallyStmt(SEHFinallyStmt *S);
132  void PrintOMPExecutableDirective(OMPExecutableDirective *S,
133  bool ForceNoStmt = false);
134 
135  void PrintExpr(Expr *E) {
136  if (E)
137  Visit(E);
138  else
139  OS << "<null expr>";
140  }
141 
142  raw_ostream &Indent(int Delta = 0) {
143  for (int i = 0, e = IndentLevel+Delta; i < e; ++i)
144  OS << " ";
145  return OS;
146  }
147 
148  void Visit(Stmt* S) {
149  if (Helper && Helper->handledStmt(S,OS))
150  return;
152  }
153 
154  void VisitStmt(Stmt *Node) LLVM_ATTRIBUTE_UNUSED {
155  Indent() << "<<unknown stmt type>>" << NL;
156  }
157 
158  void VisitExpr(Expr *Node) LLVM_ATTRIBUTE_UNUSED {
159  OS << "<<unknown expr type>>";
160  }
161 
162  void VisitCXXNamedCastExpr(CXXNamedCastExpr *Node);
163 
164 #define ABSTRACT_STMT(CLASS)
165 #define STMT(CLASS, PARENT) \
166  void Visit##CLASS(CLASS *Node);
167 #include "clang/AST/StmtNodes.inc"
168  };
169 
170 } // namespace
171 
172 //===----------------------------------------------------------------------===//
173 // Stmt printing methods.
174 //===----------------------------------------------------------------------===//
175 
176 /// PrintRawCompoundStmt - Print a compound stmt without indenting the {, and
177 /// with no newline after the }.
178 void StmtPrinter::PrintRawCompoundStmt(CompoundStmt *Node) {
179  OS << "{" << NL;
180  for (auto *I : Node->body())
181  PrintStmt(I);
182 
183  Indent() << "}";
184 }
185 
186 void StmtPrinter::PrintRawDecl(Decl *D) {
187  D->print(OS, Policy, IndentLevel);
188 }
189 
190 void StmtPrinter::PrintRawDeclStmt(const DeclStmt *S) {
191  SmallVector<Decl *, 2> Decls(S->decls());
192  Decl::printGroup(Decls.data(), Decls.size(), OS, Policy, IndentLevel);
193 }
194 
195 void StmtPrinter::VisitNullStmt(NullStmt *Node) {
196  Indent() << ";" << NL;
197 }
198 
199 void StmtPrinter::VisitDeclStmt(DeclStmt *Node) {
200  Indent();
201  PrintRawDeclStmt(Node);
202  OS << ";" << NL;
203 }
204 
205 void StmtPrinter::VisitCompoundStmt(CompoundStmt *Node) {
206  Indent();
207  PrintRawCompoundStmt(Node);
208  OS << "" << NL;
209 }
210 
211 void StmtPrinter::VisitCaseStmt(CaseStmt *Node) {
212  Indent(-1) << "case ";
213  PrintExpr(Node->getLHS());
214  if (Node->getRHS()) {
215  OS << " ... ";
216  PrintExpr(Node->getRHS());
217  }
218  OS << ":" << NL;
219 
220  PrintStmt(Node->getSubStmt(), 0);
221 }
222 
223 void StmtPrinter::VisitDefaultStmt(DefaultStmt *Node) {
224  Indent(-1) << "default:" << NL;
225  PrintStmt(Node->getSubStmt(), 0);
226 }
227 
228 void StmtPrinter::VisitLabelStmt(LabelStmt *Node) {
229  Indent(-1) << Node->getName() << ":" << NL;
230  PrintStmt(Node->getSubStmt(), 0);
231 }
232 
233 void StmtPrinter::VisitAttributedStmt(AttributedStmt *Node) {
234  for (const auto *Attr : Node->getAttrs()) {
235  Attr->printPretty(OS, Policy);
236  }
237 
238  PrintStmt(Node->getSubStmt(), 0);
239 }
240 
241 void StmtPrinter::PrintRawIfStmt(IfStmt *If) {
242  OS << "if (";
243  if (If->getInit())
244  PrintInitStmt(If->getInit(), 4);
245  if (const DeclStmt *DS = If->getConditionVariableDeclStmt())
246  PrintRawDeclStmt(DS);
247  else
248  PrintExpr(If->getCond());
249  OS << ')';
250 
251  if (auto *CS = dyn_cast<CompoundStmt>(If->getThen())) {
252  OS << ' ';
253  PrintRawCompoundStmt(CS);
254  OS << (If->getElse() ? " " : NL);
255  } else {
256  OS << NL;
257  PrintStmt(If->getThen());
258  if (If->getElse()) Indent();
259  }
260 
261  if (Stmt *Else = If->getElse()) {
262  OS << "else";
263 
264  if (auto *CS = dyn_cast<CompoundStmt>(Else)) {
265  OS << ' ';
266  PrintRawCompoundStmt(CS);
267  OS << NL;
268  } else if (auto *ElseIf = dyn_cast<IfStmt>(Else)) {
269  OS << ' ';
270  PrintRawIfStmt(ElseIf);
271  } else {
272  OS << NL;
273  PrintStmt(If->getElse());
274  }
275  }
276 }
277 
278 void StmtPrinter::VisitIfStmt(IfStmt *If) {
279  Indent();
280  PrintRawIfStmt(If);
281 }
282 
283 void StmtPrinter::VisitSwitchStmt(SwitchStmt *Node) {
284  Indent() << "switch (";
285  if (Node->getInit())
286  PrintInitStmt(Node->getInit(), 8);
287  if (const DeclStmt *DS = Node->getConditionVariableDeclStmt())
288  PrintRawDeclStmt(DS);
289  else
290  PrintExpr(Node->getCond());
291  OS << ")";
292  PrintControlledStmt(Node->getBody());
293 }
294 
295 void StmtPrinter::VisitWhileStmt(WhileStmt *Node) {
296  Indent() << "while (";
297  if (const DeclStmt *DS = Node->getConditionVariableDeclStmt())
298  PrintRawDeclStmt(DS);
299  else
300  PrintExpr(Node->getCond());
301  OS << ")" << NL;
302  PrintStmt(Node->getBody());
303 }
304 
305 void StmtPrinter::VisitDoStmt(DoStmt *Node) {
306  Indent() << "do ";
307  if (auto *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
308  PrintRawCompoundStmt(CS);
309  OS << " ";
310  } else {
311  OS << NL;
312  PrintStmt(Node->getBody());
313  Indent();
314  }
315 
316  OS << "while (";
317  PrintExpr(Node->getCond());
318  OS << ");" << NL;
319 }
320 
321 void StmtPrinter::VisitForStmt(ForStmt *Node) {
322  Indent() << "for (";
323  if (Node->getInit())
324  PrintInitStmt(Node->getInit(), 5);
325  else
326  OS << (Node->getCond() ? "; " : ";");
327  if (Node->getCond())
328  PrintExpr(Node->getCond());
329  OS << ";";
330  if (Node->getInc()) {
331  OS << " ";
332  PrintExpr(Node->getInc());
333  }
334  OS << ")";
335  PrintControlledStmt(Node->getBody());
336 }
337 
338 void StmtPrinter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *Node) {
339  Indent() << "for (";
340  if (auto *DS = dyn_cast<DeclStmt>(Node->getElement()))
341  PrintRawDeclStmt(DS);
342  else
343  PrintExpr(cast<Expr>(Node->getElement()));
344  OS << " in ";
345  PrintExpr(Node->getCollection());
346  OS << ")";
347  PrintControlledStmt(Node->getBody());
348 }
349 
350 void StmtPrinter::VisitCXXForRangeStmt(CXXForRangeStmt *Node) {
351  Indent() << "for (";
352  if (Node->getInit())
353  PrintInitStmt(Node->getInit(), 5);
354  PrintingPolicy SubPolicy(Policy);
355  SubPolicy.SuppressInitializers = true;
356  Node->getLoopVariable()->print(OS, SubPolicy, IndentLevel);
357  OS << " : ";
358  PrintExpr(Node->getRangeInit());
359  OS << ")";
360  PrintControlledStmt(Node->getBody());
361 }
362 
363 void StmtPrinter::VisitMSDependentExistsStmt(MSDependentExistsStmt *Node) {
364  Indent();
365  if (Node->isIfExists())
366  OS << "__if_exists (";
367  else
368  OS << "__if_not_exists (";
369 
370  if (NestedNameSpecifier *Qualifier
372  Qualifier->print(OS, Policy);
373 
374  OS << Node->getNameInfo() << ") ";
375 
376  PrintRawCompoundStmt(Node->getSubStmt());
377 }
378 
379 void StmtPrinter::VisitGotoStmt(GotoStmt *Node) {
380  Indent() << "goto " << Node->getLabel()->getName() << ";";
381  if (Policy.IncludeNewlines) OS << NL;
382 }
383 
384 void StmtPrinter::VisitIndirectGotoStmt(IndirectGotoStmt *Node) {
385  Indent() << "goto *";
386  PrintExpr(Node->getTarget());
387  OS << ";";
388  if (Policy.IncludeNewlines) OS << NL;
389 }
390 
391 void StmtPrinter::VisitContinueStmt(ContinueStmt *Node) {
392  Indent() << "continue;";
393  if (Policy.IncludeNewlines) OS << NL;
394 }
395 
396 void StmtPrinter::VisitBreakStmt(BreakStmt *Node) {
397  Indent() << "break;";
398  if (Policy.IncludeNewlines) OS << NL;
399 }
400 
401 void StmtPrinter::VisitReturnStmt(ReturnStmt *Node) {
402  Indent() << "return";
403  if (Node->getRetValue()) {
404  OS << " ";
405  PrintExpr(Node->getRetValue());
406  }
407  OS << ";";
408  if (Policy.IncludeNewlines) OS << NL;
409 }
410 
411 void StmtPrinter::VisitGCCAsmStmt(GCCAsmStmt *Node) {
412  Indent() << "asm ";
413 
414  if (Node->isVolatile())
415  OS << "volatile ";
416 
417  OS << "(";
418  VisitStringLiteral(Node->getAsmString());
419 
420  // Outputs
421  if (Node->getNumOutputs() != 0 || Node->getNumInputs() != 0 ||
422  Node->getNumClobbers() != 0)
423  OS << " : ";
424 
425  for (unsigned i = 0, e = Node->getNumOutputs(); i != e; ++i) {
426  if (i != 0)
427  OS << ", ";
428 
429  if (!Node->getOutputName(i).empty()) {
430  OS << '[';
431  OS << Node->getOutputName(i);
432  OS << "] ";
433  }
434 
435  VisitStringLiteral(Node->getOutputConstraintLiteral(i));
436  OS << " (";
437  Visit(Node->getOutputExpr(i));
438  OS << ")";
439  }
440 
441  // Inputs
442  if (Node->getNumInputs() != 0 || Node->getNumClobbers() != 0)
443  OS << " : ";
444 
445  for (unsigned i = 0, e = Node->getNumInputs(); i != e; ++i) {
446  if (i != 0)
447  OS << ", ";
448 
449  if (!Node->getInputName(i).empty()) {
450  OS << '[';
451  OS << Node->getInputName(i);
452  OS << "] ";
453  }
454 
455  VisitStringLiteral(Node->getInputConstraintLiteral(i));
456  OS << " (";
457  Visit(Node->getInputExpr(i));
458  OS << ")";
459  }
460 
461  // Clobbers
462  if (Node->getNumClobbers() != 0)
463  OS << " : ";
464 
465  for (unsigned i = 0, e = Node->getNumClobbers(); i != e; ++i) {
466  if (i != 0)
467  OS << ", ";
468 
469  VisitStringLiteral(Node->getClobberStringLiteral(i));
470  }
471 
472  OS << ");";
473  if (Policy.IncludeNewlines) OS << NL;
474 }
475 
476 void StmtPrinter::VisitMSAsmStmt(MSAsmStmt *Node) {
477  // FIXME: Implement MS style inline asm statement printer.
478  Indent() << "__asm ";
479  if (Node->hasBraces())
480  OS << "{" << NL;
481  OS << Node->getAsmString() << NL;
482  if (Node->hasBraces())
483  Indent() << "}" << NL;
484 }
485 
486 void StmtPrinter::VisitCapturedStmt(CapturedStmt *Node) {
487  PrintStmt(Node->getCapturedDecl()->getBody());
488 }
489 
490 void StmtPrinter::VisitObjCAtTryStmt(ObjCAtTryStmt *Node) {
491  Indent() << "@try";
492  if (auto *TS = dyn_cast<CompoundStmt>(Node->getTryBody())) {
493  PrintRawCompoundStmt(TS);
494  OS << NL;
495  }
496 
497  for (unsigned I = 0, N = Node->getNumCatchStmts(); I != N; ++I) {
498  ObjCAtCatchStmt *catchStmt = Node->getCatchStmt(I);
499  Indent() << "@catch(";
500  if (catchStmt->getCatchParamDecl()) {
501  if (Decl *DS = catchStmt->getCatchParamDecl())
502  PrintRawDecl(DS);
503  }
504  OS << ")";
505  if (auto *CS = dyn_cast<CompoundStmt>(catchStmt->getCatchBody())) {
506  PrintRawCompoundStmt(CS);
507  OS << NL;
508  }
509  }
510 
511  if (auto *FS = static_cast<ObjCAtFinallyStmt *>(Node->getFinallyStmt())) {
512  Indent() << "@finally";
513  PrintRawCompoundStmt(dyn_cast<CompoundStmt>(FS->getFinallyBody()));
514  OS << NL;
515  }
516 }
517 
518 void StmtPrinter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *Node) {
519 }
520 
521 void StmtPrinter::VisitObjCAtCatchStmt (ObjCAtCatchStmt *Node) {
522  Indent() << "@catch (...) { /* todo */ } " << NL;
523 }
524 
525 void StmtPrinter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *Node) {
526  Indent() << "@throw";
527  if (Node->getThrowExpr()) {
528  OS << " ";
529  PrintExpr(Node->getThrowExpr());
530  }
531  OS << ";" << NL;
532 }
533 
534 void StmtPrinter::VisitObjCAvailabilityCheckExpr(
536  OS << "@available(...)";
537 }
538 
539 void StmtPrinter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *Node) {
540  Indent() << "@synchronized (";
541  PrintExpr(Node->getSynchExpr());
542  OS << ")";
543  PrintRawCompoundStmt(Node->getSynchBody());
544  OS << NL;
545 }
546 
547 void StmtPrinter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *Node) {
548  Indent() << "@autoreleasepool";
549  PrintRawCompoundStmt(dyn_cast<CompoundStmt>(Node->getSubStmt()));
550  OS << NL;
551 }
552 
553 void StmtPrinter::PrintRawCXXCatchStmt(CXXCatchStmt *Node) {
554  OS << "catch (";
555  if (Decl *ExDecl = Node->getExceptionDecl())
556  PrintRawDecl(ExDecl);
557  else
558  OS << "...";
559  OS << ") ";
560  PrintRawCompoundStmt(cast<CompoundStmt>(Node->getHandlerBlock()));
561 }
562 
563 void StmtPrinter::VisitCXXCatchStmt(CXXCatchStmt *Node) {
564  Indent();
565  PrintRawCXXCatchStmt(Node);
566  OS << NL;
567 }
568 
569 void StmtPrinter::VisitCXXTryStmt(CXXTryStmt *Node) {
570  Indent() << "try ";
571  PrintRawCompoundStmt(Node->getTryBlock());
572  for (unsigned i = 0, e = Node->getNumHandlers(); i < e; ++i) {
573  OS << " ";
574  PrintRawCXXCatchStmt(Node->getHandler(i));
575  }
576  OS << NL;
577 }
578 
579 void StmtPrinter::VisitSEHTryStmt(SEHTryStmt *Node) {
580  Indent() << (Node->getIsCXXTry() ? "try " : "__try ");
581  PrintRawCompoundStmt(Node->getTryBlock());
582  SEHExceptStmt *E = Node->getExceptHandler();
583  SEHFinallyStmt *F = Node->getFinallyHandler();
584  if(E)
585  PrintRawSEHExceptHandler(E);
586  else {
587  assert(F && "Must have a finally block...");
588  PrintRawSEHFinallyStmt(F);
589  }
590  OS << NL;
591 }
592 
593 void StmtPrinter::PrintRawSEHFinallyStmt(SEHFinallyStmt *Node) {
594  OS << "__finally ";
595  PrintRawCompoundStmt(Node->getBlock());
596  OS << NL;
597 }
598 
599 void StmtPrinter::PrintRawSEHExceptHandler(SEHExceptStmt *Node) {
600  OS << "__except (";
601  VisitExpr(Node->getFilterExpr());
602  OS << ")" << NL;
603  PrintRawCompoundStmt(Node->getBlock());
604  OS << NL;
605 }
606 
607 void StmtPrinter::VisitSEHExceptStmt(SEHExceptStmt *Node) {
608  Indent();
609  PrintRawSEHExceptHandler(Node);
610  OS << NL;
611 }
612 
613 void StmtPrinter::VisitSEHFinallyStmt(SEHFinallyStmt *Node) {
614  Indent();
615  PrintRawSEHFinallyStmt(Node);
616  OS << NL;
617 }
618 
619 void StmtPrinter::VisitSEHLeaveStmt(SEHLeaveStmt *Node) {
620  Indent() << "__leave;";
621  if (Policy.IncludeNewlines) OS << NL;
622 }
623 
624 //===----------------------------------------------------------------------===//
625 // OpenMP directives printing methods
626 //===----------------------------------------------------------------------===//
627 
628 void StmtPrinter::PrintOMPExecutableDirective(OMPExecutableDirective *S,
629  bool ForceNoStmt) {
630  OMPClausePrinter Printer(OS, Policy);
631  ArrayRef<OMPClause *> Clauses = S->clauses();
632  for (auto *Clause : Clauses)
633  if (Clause && !Clause->isImplicit()) {
634  OS << ' ';
635  Printer.Visit(Clause);
636  }
637  OS << NL;
638  if (!ForceNoStmt && S->hasAssociatedStmt())
639  PrintStmt(S->getInnermostCapturedStmt()->getCapturedStmt());
640 }
641 
642 void StmtPrinter::VisitOMPParallelDirective(OMPParallelDirective *Node) {
643  Indent() << "#pragma omp parallel";
644  PrintOMPExecutableDirective(Node);
645 }
646 
647 void StmtPrinter::VisitOMPSimdDirective(OMPSimdDirective *Node) {
648  Indent() << "#pragma omp simd";
649  PrintOMPExecutableDirective(Node);
650 }
651 
652 void StmtPrinter::VisitOMPForDirective(OMPForDirective *Node) {
653  Indent() << "#pragma omp for";
654  PrintOMPExecutableDirective(Node);
655 }
656 
657 void StmtPrinter::VisitOMPForSimdDirective(OMPForSimdDirective *Node) {
658  Indent() << "#pragma omp for simd";
659  PrintOMPExecutableDirective(Node);
660 }
661 
662 void StmtPrinter::VisitOMPSectionsDirective(OMPSectionsDirective *Node) {
663  Indent() << "#pragma omp sections";
664  PrintOMPExecutableDirective(Node);
665 }
666 
667 void StmtPrinter::VisitOMPSectionDirective(OMPSectionDirective *Node) {
668  Indent() << "#pragma omp section";
669  PrintOMPExecutableDirective(Node);
670 }
671 
672 void StmtPrinter::VisitOMPSingleDirective(OMPSingleDirective *Node) {
673  Indent() << "#pragma omp single";
674  PrintOMPExecutableDirective(Node);
675 }
676 
677 void StmtPrinter::VisitOMPMasterDirective(OMPMasterDirective *Node) {
678  Indent() << "#pragma omp master";
679  PrintOMPExecutableDirective(Node);
680 }
681 
682 void StmtPrinter::VisitOMPCriticalDirective(OMPCriticalDirective *Node) {
683  Indent() << "#pragma omp critical";
684  if (Node->getDirectiveName().getName()) {
685  OS << " (";
686  Node->getDirectiveName().printName(OS);
687  OS << ")";
688  }
689  PrintOMPExecutableDirective(Node);
690 }
691 
692 void StmtPrinter::VisitOMPParallelForDirective(OMPParallelForDirective *Node) {
693  Indent() << "#pragma omp parallel for";
694  PrintOMPExecutableDirective(Node);
695 }
696 
697 void StmtPrinter::VisitOMPParallelForSimdDirective(
699  Indent() << "#pragma omp parallel for simd";
700  PrintOMPExecutableDirective(Node);
701 }
702 
703 void StmtPrinter::VisitOMPParallelSectionsDirective(
705  Indent() << "#pragma omp parallel sections";
706  PrintOMPExecutableDirective(Node);
707 }
708 
709 void StmtPrinter::VisitOMPTaskDirective(OMPTaskDirective *Node) {
710  Indent() << "#pragma omp task";
711  PrintOMPExecutableDirective(Node);
712 }
713 
714 void StmtPrinter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *Node) {
715  Indent() << "#pragma omp taskyield";
716  PrintOMPExecutableDirective(Node);
717 }
718 
719 void StmtPrinter::VisitOMPBarrierDirective(OMPBarrierDirective *Node) {
720  Indent() << "#pragma omp barrier";
721  PrintOMPExecutableDirective(Node);
722 }
723 
724 void StmtPrinter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *Node) {
725  Indent() << "#pragma omp taskwait";
726  PrintOMPExecutableDirective(Node);
727 }
728 
729 void StmtPrinter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *Node) {
730  Indent() << "#pragma omp taskgroup";
731  PrintOMPExecutableDirective(Node);
732 }
733 
734 void StmtPrinter::VisitOMPFlushDirective(OMPFlushDirective *Node) {
735  Indent() << "#pragma omp flush";
736  PrintOMPExecutableDirective(Node);
737 }
738 
739 void StmtPrinter::VisitOMPOrderedDirective(OMPOrderedDirective *Node) {
740  Indent() << "#pragma omp ordered";
741  PrintOMPExecutableDirective(Node, Node->hasClausesOfKind<OMPDependClause>());
742 }
743 
744 void StmtPrinter::VisitOMPAtomicDirective(OMPAtomicDirective *Node) {
745  Indent() << "#pragma omp atomic";
746  PrintOMPExecutableDirective(Node);
747 }
748 
749 void StmtPrinter::VisitOMPTargetDirective(OMPTargetDirective *Node) {
750  Indent() << "#pragma omp target";
751  PrintOMPExecutableDirective(Node);
752 }
753 
754 void StmtPrinter::VisitOMPTargetDataDirective(OMPTargetDataDirective *Node) {
755  Indent() << "#pragma omp target data";
756  PrintOMPExecutableDirective(Node);
757 }
758 
759 void StmtPrinter::VisitOMPTargetEnterDataDirective(
761  Indent() << "#pragma omp target enter data";
762  PrintOMPExecutableDirective(Node, /*ForceNoStmt=*/true);
763 }
764 
765 void StmtPrinter::VisitOMPTargetExitDataDirective(
767  Indent() << "#pragma omp target exit data";
768  PrintOMPExecutableDirective(Node, /*ForceNoStmt=*/true);
769 }
770 
771 void StmtPrinter::VisitOMPTargetParallelDirective(
773  Indent() << "#pragma omp target parallel";
774  PrintOMPExecutableDirective(Node);
775 }
776 
777 void StmtPrinter::VisitOMPTargetParallelForDirective(
779  Indent() << "#pragma omp target parallel for";
780  PrintOMPExecutableDirective(Node);
781 }
782 
783 void StmtPrinter::VisitOMPTeamsDirective(OMPTeamsDirective *Node) {
784  Indent() << "#pragma omp teams";
785  PrintOMPExecutableDirective(Node);
786 }
787 
788 void StmtPrinter::VisitOMPCancellationPointDirective(
790  Indent() << "#pragma omp cancellation point "
792  PrintOMPExecutableDirective(Node);
793 }
794 
795 void StmtPrinter::VisitOMPCancelDirective(OMPCancelDirective *Node) {
796  Indent() << "#pragma omp cancel "
798  PrintOMPExecutableDirective(Node);
799 }
800 
801 void StmtPrinter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *Node) {
802  Indent() << "#pragma omp taskloop";
803  PrintOMPExecutableDirective(Node);
804 }
805 
806 void StmtPrinter::VisitOMPTaskLoopSimdDirective(
807  OMPTaskLoopSimdDirective *Node) {
808  Indent() << "#pragma omp taskloop simd";
809  PrintOMPExecutableDirective(Node);
810 }
811 
812 void StmtPrinter::VisitOMPDistributeDirective(OMPDistributeDirective *Node) {
813  Indent() << "#pragma omp distribute";
814  PrintOMPExecutableDirective(Node);
815 }
816 
817 void StmtPrinter::VisitOMPTargetUpdateDirective(
818  OMPTargetUpdateDirective *Node) {
819  Indent() << "#pragma omp target update";
820  PrintOMPExecutableDirective(Node, /*ForceNoStmt=*/true);
821 }
822 
823 void StmtPrinter::VisitOMPDistributeParallelForDirective(
825  Indent() << "#pragma omp distribute parallel for";
826  PrintOMPExecutableDirective(Node);
827 }
828 
829 void StmtPrinter::VisitOMPDistributeParallelForSimdDirective(
831  Indent() << "#pragma omp distribute parallel for simd";
832  PrintOMPExecutableDirective(Node);
833 }
834 
835 void StmtPrinter::VisitOMPDistributeSimdDirective(
837  Indent() << "#pragma omp distribute simd";
838  PrintOMPExecutableDirective(Node);
839 }
840 
841 void StmtPrinter::VisitOMPTargetParallelForSimdDirective(
843  Indent() << "#pragma omp target parallel for simd";
844  PrintOMPExecutableDirective(Node);
845 }
846 
847 void StmtPrinter::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *Node) {
848  Indent() << "#pragma omp target simd";
849  PrintOMPExecutableDirective(Node);
850 }
851 
852 void StmtPrinter::VisitOMPTeamsDistributeDirective(
854  Indent() << "#pragma omp teams distribute";
855  PrintOMPExecutableDirective(Node);
856 }
857 
858 void StmtPrinter::VisitOMPTeamsDistributeSimdDirective(
860  Indent() << "#pragma omp teams distribute simd";
861  PrintOMPExecutableDirective(Node);
862 }
863 
864 void StmtPrinter::VisitOMPTeamsDistributeParallelForSimdDirective(
866  Indent() << "#pragma omp teams distribute parallel for simd";
867  PrintOMPExecutableDirective(Node);
868 }
869 
870 void StmtPrinter::VisitOMPTeamsDistributeParallelForDirective(
872  Indent() << "#pragma omp teams distribute parallel for";
873  PrintOMPExecutableDirective(Node);
874 }
875 
876 void StmtPrinter::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *Node) {
877  Indent() << "#pragma omp target teams";
878  PrintOMPExecutableDirective(Node);
879 }
880 
881 void StmtPrinter::VisitOMPTargetTeamsDistributeDirective(
883  Indent() << "#pragma omp target teams distribute";
884  PrintOMPExecutableDirective(Node);
885 }
886 
887 void StmtPrinter::VisitOMPTargetTeamsDistributeParallelForDirective(
889  Indent() << "#pragma omp target teams distribute parallel for";
890  PrintOMPExecutableDirective(Node);
891 }
892 
893 void StmtPrinter::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
895  Indent() << "#pragma omp target teams distribute parallel for simd";
896  PrintOMPExecutableDirective(Node);
897 }
898 
899 void StmtPrinter::VisitOMPTargetTeamsDistributeSimdDirective(
901  Indent() << "#pragma omp target teams distribute simd";
902  PrintOMPExecutableDirective(Node);
903 }
904 
905 //===----------------------------------------------------------------------===//
906 // Expr printing methods.
907 //===----------------------------------------------------------------------===//
908 
909 void StmtPrinter::VisitDeclRefExpr(DeclRefExpr *Node) {
910  if (const auto *OCED = dyn_cast<OMPCapturedExprDecl>(Node->getDecl())) {
911  OCED->getInit()->IgnoreImpCasts()->printPretty(OS, nullptr, Policy);
912  return;
913  }
914  if (NestedNameSpecifier *Qualifier = Node->getQualifier())
915  Qualifier->print(OS, Policy);
916  if (Node->hasTemplateKeyword())
917  OS << "template ";
918  OS << Node->getNameInfo();
919  if (Node->hasExplicitTemplateArgs())
920  printTemplateArgumentList(OS, Node->template_arguments(), Policy);
921 }
922 
923 void StmtPrinter::VisitDependentScopeDeclRefExpr(
925  if (NestedNameSpecifier *Qualifier = Node->getQualifier())
926  Qualifier->print(OS, Policy);
927  if (Node->hasTemplateKeyword())
928  OS << "template ";
929  OS << Node->getNameInfo();
930  if (Node->hasExplicitTemplateArgs())
931  printTemplateArgumentList(OS, Node->template_arguments(), Policy);
932 }
933 
934 void StmtPrinter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *Node) {
935  if (Node->getQualifier())
936  Node->getQualifier()->print(OS, Policy);
937  if (Node->hasTemplateKeyword())
938  OS << "template ";
939  OS << Node->getNameInfo();
940  if (Node->hasExplicitTemplateArgs())
941  printTemplateArgumentList(OS, Node->template_arguments(), Policy);
942 }
943 
944 static bool isImplicitSelf(const Expr *E) {
945  if (const auto *DRE = dyn_cast<DeclRefExpr>(E)) {
946  if (const auto *PD = dyn_cast<ImplicitParamDecl>(DRE->getDecl())) {
947  if (PD->getParameterKind() == ImplicitParamDecl::ObjCSelf &&
948  DRE->getBeginLoc().isInvalid())
949  return true;
950  }
951  }
952  return false;
953 }
954 
955 void StmtPrinter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node) {
956  if (Node->getBase()) {
957  if (!Policy.SuppressImplicitBase ||
958  !isImplicitSelf(Node->getBase()->IgnoreImpCasts())) {
959  PrintExpr(Node->getBase());
960  OS << (Node->isArrow() ? "->" : ".");
961  }
962  }
963  OS << *Node->getDecl();
964 }
965 
966 void StmtPrinter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node) {
967  if (Node->isSuperReceiver())
968  OS << "super.";
969  else if (Node->isObjectReceiver() && Node->getBase()) {
970  PrintExpr(Node->getBase());
971  OS << ".";
972  } else if (Node->isClassReceiver() && Node->getClassReceiver()) {
973  OS << Node->getClassReceiver()->getName() << ".";
974  }
975 
976  if (Node->isImplicitProperty()) {
977  if (const auto *Getter = Node->getImplicitPropertyGetter())
978  Getter->getSelector().print(OS);
979  else
982  } else
983  OS << Node->getExplicitProperty()->getName();
984 }
985 
986 void StmtPrinter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *Node) {
987  PrintExpr(Node->getBaseExpr());
988  OS << "[";
989  PrintExpr(Node->getKeyExpr());
990  OS << "]";
991 }
992 
993 void StmtPrinter::VisitPredefinedExpr(PredefinedExpr *Node) {
995 }
996 
997 void StmtPrinter::VisitCharacterLiteral(CharacterLiteral *Node) {
998  unsigned value = Node->getValue();
999 
1000  switch (Node->getKind()) {
1001  case CharacterLiteral::Ascii: break; // no prefix.
1002  case CharacterLiteral::Wide: OS << 'L'; break;
1003  case CharacterLiteral::UTF8: OS << "u8"; break;
1004  case CharacterLiteral::UTF16: OS << 'u'; break;
1005  case CharacterLiteral::UTF32: OS << 'U'; break;
1006  }
1007 
1008  switch (value) {
1009  case '\\':
1010  OS << "'\\\\'";
1011  break;
1012  case '\'':
1013  OS << "'\\''";
1014  break;
1015  case '\a':
1016  // TODO: K&R: the meaning of '\\a' is different in traditional C
1017  OS << "'\\a'";
1018  break;
1019  case '\b':
1020  OS << "'\\b'";
1021  break;
1022  // Nonstandard escape sequence.
1023  /*case '\e':
1024  OS << "'\\e'";
1025  break;*/
1026  case '\f':
1027  OS << "'\\f'";
1028  break;
1029  case '\n':
1030  OS << "'\\n'";
1031  break;
1032  case '\r':
1033  OS << "'\\r'";
1034  break;
1035  case '\t':
1036  OS << "'\\t'";
1037  break;
1038  case '\v':
1039  OS << "'\\v'";
1040  break;
1041  default:
1042  // A character literal might be sign-extended, which
1043  // would result in an invalid \U escape sequence.
1044  // FIXME: multicharacter literals such as '\xFF\xFF\xFF\xFF'
1045  // are not correctly handled.
1046  if ((value & ~0xFFu) == ~0xFFu && Node->getKind() == CharacterLiteral::Ascii)
1047  value &= 0xFFu;
1048  if (value < 256 && isPrintable((unsigned char)value))
1049  OS << "'" << (char)value << "'";
1050  else if (value < 256)
1051  OS << "'\\x" << llvm::format("%02x", value) << "'";
1052  else if (value <= 0xFFFF)
1053  OS << "'\\u" << llvm::format("%04x", value) << "'";
1054  else
1055  OS << "'\\U" << llvm::format("%08x", value) << "'";
1056  }
1057 }
1058 
1059 /// Prints the given expression using the original source text. Returns true on
1060 /// success, false otherwise.
1061 static bool printExprAsWritten(raw_ostream &OS, Expr *E,
1062  const ASTContext *Context) {
1063  if (!Context)
1064  return false;
1065  bool Invalid = false;
1066  StringRef Source = Lexer::getSourceText(
1068  Context->getSourceManager(), Context->getLangOpts(), &Invalid);
1069  if (!Invalid) {
1070  OS << Source;
1071  return true;
1072  }
1073  return false;
1074 }
1075 
1076 void StmtPrinter::VisitIntegerLiteral(IntegerLiteral *Node) {
1077  if (Policy.ConstantsAsWritten && printExprAsWritten(OS, Node, Context))
1078  return;
1079  bool isSigned = Node->getType()->isSignedIntegerType();
1080  OS << Node->getValue().toString(10, isSigned);
1081 
1082  // Emit suffixes. Integer literals are always a builtin integer type.
1083  switch (Node->getType()->getAs<BuiltinType>()->getKind()) {
1084  default: llvm_unreachable("Unexpected type for integer literal!");
1085  case BuiltinType::Char_S:
1086  case BuiltinType::Char_U: OS << "i8"; break;
1087  case BuiltinType::UChar: OS << "Ui8"; break;
1088  case BuiltinType::Short: OS << "i16"; break;
1089  case BuiltinType::UShort: OS << "Ui16"; break;
1090  case BuiltinType::Int: break; // no suffix.
1091  case BuiltinType::UInt: OS << 'U'; break;
1092  case BuiltinType::Long: OS << 'L'; break;
1093  case BuiltinType::ULong: OS << "UL"; break;
1094  case BuiltinType::LongLong: OS << "LL"; break;
1095  case BuiltinType::ULongLong: OS << "ULL"; break;
1096  }
1097 }
1098 
1099 void StmtPrinter::VisitFixedPointLiteral(FixedPointLiteral *Node) {
1100  if (Policy.ConstantsAsWritten && printExprAsWritten(OS, Node, Context))
1101  return;
1102  OS << Node->getValueAsString(/*Radix=*/10);
1103 
1104  switch (Node->getType()->getAs<BuiltinType>()->getKind()) {
1105  default: llvm_unreachable("Unexpected type for fixed point literal!");
1106  case BuiltinType::ShortFract: OS << "hr"; break;
1107  case BuiltinType::ShortAccum: OS << "hk"; break;
1108  case BuiltinType::UShortFract: OS << "uhr"; break;
1109  case BuiltinType::UShortAccum: OS << "uhk"; break;
1110  case BuiltinType::Fract: OS << "r"; break;
1111  case BuiltinType::Accum: OS << "k"; break;
1112  case BuiltinType::UFract: OS << "ur"; break;
1113  case BuiltinType::UAccum: OS << "uk"; break;
1114  case BuiltinType::LongFract: OS << "lr"; break;
1115  case BuiltinType::LongAccum: OS << "lk"; break;
1116  case BuiltinType::ULongFract: OS << "ulr"; break;
1117  case BuiltinType::ULongAccum: OS << "ulk"; break;
1118  }
1119 }
1120 
1121 static void PrintFloatingLiteral(raw_ostream &OS, FloatingLiteral *Node,
1122  bool PrintSuffix) {
1123  SmallString<16> Str;
1124  Node->getValue().toString(Str);
1125  OS << Str;
1126  if (Str.find_first_not_of("-0123456789") == StringRef::npos)
1127  OS << '.'; // Trailing dot in order to separate from ints.
1128 
1129  if (!PrintSuffix)
1130  return;
1131 
1132  // Emit suffixes. Float literals are always a builtin float type.
1133  switch (Node->getType()->getAs<BuiltinType>()->getKind()) {
1134  default: llvm_unreachable("Unexpected type for float literal!");
1135  case BuiltinType::Half: break; // FIXME: suffix?
1136  case BuiltinType::Double: break; // no suffix.
1137  case BuiltinType::Float16: OS << "F16"; break;
1138  case BuiltinType::Float: OS << 'F'; break;
1139  case BuiltinType::LongDouble: OS << 'L'; break;
1140  case BuiltinType::Float128: OS << 'Q'; break;
1141  }
1142 }
1143 
1144 void StmtPrinter::VisitFloatingLiteral(FloatingLiteral *Node) {
1145  if (Policy.ConstantsAsWritten && printExprAsWritten(OS, Node, Context))
1146  return;
1147  PrintFloatingLiteral(OS, Node, /*PrintSuffix=*/true);
1148 }
1149 
1150 void StmtPrinter::VisitImaginaryLiteral(ImaginaryLiteral *Node) {
1151  PrintExpr(Node->getSubExpr());
1152  OS << "i";
1153 }
1154 
1155 void StmtPrinter::VisitStringLiteral(StringLiteral *Str) {
1156  Str->outputString(OS);
1157 }
1158 
1159 void StmtPrinter::VisitParenExpr(ParenExpr *Node) {
1160  OS << "(";
1161  PrintExpr(Node->getSubExpr());
1162  OS << ")";
1163 }
1164 
1165 void StmtPrinter::VisitUnaryOperator(UnaryOperator *Node) {
1166  if (!Node->isPostfix()) {
1167  OS << UnaryOperator::getOpcodeStr(Node->getOpcode());
1168 
1169  // Print a space if this is an "identifier operator" like __real, or if
1170  // it might be concatenated incorrectly like '+'.
1171  switch (Node->getOpcode()) {
1172  default: break;
1173  case UO_Real:
1174  case UO_Imag:
1175  case UO_Extension:
1176  OS << ' ';
1177  break;
1178  case UO_Plus:
1179  case UO_Minus:
1180  if (isa<UnaryOperator>(Node->getSubExpr()))
1181  OS << ' ';
1182  break;
1183  }
1184  }
1185  PrintExpr(Node->getSubExpr());
1186 
1187  if (Node->isPostfix())
1188  OS << UnaryOperator::getOpcodeStr(Node->getOpcode());
1189 }
1190 
1191 void StmtPrinter::VisitOffsetOfExpr(OffsetOfExpr *Node) {
1192  OS << "__builtin_offsetof(";
1193  Node->getTypeSourceInfo()->getType().print(OS, Policy);
1194  OS << ", ";
1195  bool PrintedSomething = false;
1196  for (unsigned i = 0, n = Node->getNumComponents(); i < n; ++i) {
1197  OffsetOfNode ON = Node->getComponent(i);
1198  if (ON.getKind() == OffsetOfNode::Array) {
1199  // Array node
1200  OS << "[";
1201  PrintExpr(Node->getIndexExpr(ON.getArrayExprIndex()));
1202  OS << "]";
1203  PrintedSomething = true;
1204  continue;
1205  }
1206 
1207  // Skip implicit base indirections.
1208  if (ON.getKind() == OffsetOfNode::Base)
1209  continue;
1210 
1211  // Field or identifier node.
1212  IdentifierInfo *Id = ON.getFieldName();
1213  if (!Id)
1214  continue;
1215 
1216  if (PrintedSomething)
1217  OS << ".";
1218  else
1219  PrintedSomething = true;
1220  OS << Id->getName();
1221  }
1222  OS << ")";
1223 }
1224 
1225 void StmtPrinter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *Node){
1226  switch(Node->getKind()) {
1227  case UETT_SizeOf:
1228  OS << "sizeof";
1229  break;
1230  case UETT_AlignOf:
1231  if (Policy.Alignof)
1232  OS << "alignof";
1233  else if (Policy.UnderscoreAlignof)
1234  OS << "_Alignof";
1235  else
1236  OS << "__alignof";
1237  break;
1238  case UETT_VecStep:
1239  OS << "vec_step";
1240  break;
1242  OS << "__builtin_omp_required_simd_align";
1243  break;
1244  }
1245  if (Node->isArgumentType()) {
1246  OS << '(';
1247  Node->getArgumentType().print(OS, Policy);
1248  OS << ')';
1249  } else {
1250  OS << " ";
1251  PrintExpr(Node->getArgumentExpr());
1252  }
1253 }
1254 
1255 void StmtPrinter::VisitGenericSelectionExpr(GenericSelectionExpr *Node) {
1256  OS << "_Generic(";
1257  PrintExpr(Node->getControllingExpr());
1258  for (unsigned i = 0; i != Node->getNumAssocs(); ++i) {
1259  OS << ", ";
1260  QualType T = Node->getAssocType(i);
1261  if (T.isNull())
1262  OS << "default";
1263  else
1264  T.print(OS, Policy);
1265  OS << ": ";
1266  PrintExpr(Node->getAssocExpr(i));
1267  }
1268  OS << ")";
1269 }
1270 
1271 void StmtPrinter::VisitArraySubscriptExpr(ArraySubscriptExpr *Node) {
1272  PrintExpr(Node->getLHS());
1273  OS << "[";
1274  PrintExpr(Node->getRHS());
1275  OS << "]";
1276 }
1277 
1278 void StmtPrinter::VisitOMPArraySectionExpr(OMPArraySectionExpr *Node) {
1279  PrintExpr(Node->getBase());
1280  OS << "[";
1281  if (Node->getLowerBound())
1282  PrintExpr(Node->getLowerBound());
1283  if (Node->getColonLoc().isValid()) {
1284  OS << ":";
1285  if (Node->getLength())
1286  PrintExpr(Node->getLength());
1287  }
1288  OS << "]";
1289 }
1290 
1291 void StmtPrinter::PrintCallArgs(CallExpr *Call) {
1292  for (unsigned i = 0, e = Call->getNumArgs(); i != e; ++i) {
1293  if (isa<CXXDefaultArgExpr>(Call->getArg(i))) {
1294  // Don't print any defaulted arguments
1295  break;
1296  }
1297 
1298  if (i) OS << ", ";
1299  PrintExpr(Call->getArg(i));
1300  }
1301 }
1302 
1303 void StmtPrinter::VisitCallExpr(CallExpr *Call) {
1304  PrintExpr(Call->getCallee());
1305  OS << "(";
1306  PrintCallArgs(Call);
1307  OS << ")";
1308 }
1309 
1310 static bool isImplicitThis(const Expr *E) {
1311  if (const auto *TE = dyn_cast<CXXThisExpr>(E))
1312  return TE->isImplicit();
1313  return false;
1314 }
1315 
1316 void StmtPrinter::VisitMemberExpr(MemberExpr *Node) {
1317  if (!Policy.SuppressImplicitBase || !isImplicitThis(Node->getBase())) {
1318  PrintExpr(Node->getBase());
1319 
1320  auto *ParentMember = dyn_cast<MemberExpr>(Node->getBase());
1321  FieldDecl *ParentDecl =
1322  ParentMember ? dyn_cast<FieldDecl>(ParentMember->getMemberDecl())
1323  : nullptr;
1324 
1325  if (!ParentDecl || !ParentDecl->isAnonymousStructOrUnion())
1326  OS << (Node->isArrow() ? "->" : ".");
1327  }
1328 
1329  if (auto *FD = dyn_cast<FieldDecl>(Node->getMemberDecl()))
1330  if (FD->isAnonymousStructOrUnion())
1331  return;
1332 
1333  if (NestedNameSpecifier *Qualifier = Node->getQualifier())
1334  Qualifier->print(OS, Policy);
1335  if (Node->hasTemplateKeyword())
1336  OS << "template ";
1337  OS << Node->getMemberNameInfo();
1338  if (Node->hasExplicitTemplateArgs())
1339  printTemplateArgumentList(OS, Node->template_arguments(), Policy);
1340 }
1341 
1342 void StmtPrinter::VisitObjCIsaExpr(ObjCIsaExpr *Node) {
1343  PrintExpr(Node->getBase());
1344  OS << (Node->isArrow() ? "->isa" : ".isa");
1345 }
1346 
1347 void StmtPrinter::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) {
1348  PrintExpr(Node->getBase());
1349  OS << ".";
1350  OS << Node->getAccessor().getName();
1351 }
1352 
1353 void StmtPrinter::VisitCStyleCastExpr(CStyleCastExpr *Node) {
1354  OS << '(';
1355  Node->getTypeAsWritten().print(OS, Policy);
1356  OS << ')';
1357  PrintExpr(Node->getSubExpr());
1358 }
1359 
1360 void StmtPrinter::VisitCompoundLiteralExpr(CompoundLiteralExpr *Node) {
1361  OS << '(';
1362  Node->getType().print(OS, Policy);
1363  OS << ')';
1364  PrintExpr(Node->getInitializer());
1365 }
1366 
1367 void StmtPrinter::VisitImplicitCastExpr(ImplicitCastExpr *Node) {
1368  // No need to print anything, simply forward to the subexpression.
1369  PrintExpr(Node->getSubExpr());
1370 }
1371 
1372 void StmtPrinter::VisitBinaryOperator(BinaryOperator *Node) {
1373  PrintExpr(Node->getLHS());
1374  OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
1375  PrintExpr(Node->getRHS());
1376 }
1377 
1378 void StmtPrinter::VisitCompoundAssignOperator(CompoundAssignOperator *Node) {
1379  PrintExpr(Node->getLHS());
1380  OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
1381  PrintExpr(Node->getRHS());
1382 }
1383 
1384 void StmtPrinter::VisitConditionalOperator(ConditionalOperator *Node) {
1385  PrintExpr(Node->getCond());
1386  OS << " ? ";
1387  PrintExpr(Node->getLHS());
1388  OS << " : ";
1389  PrintExpr(Node->getRHS());
1390 }
1391 
1392 // GNU extensions.
1393 
1394 void
1395 StmtPrinter::VisitBinaryConditionalOperator(BinaryConditionalOperator *Node) {
1396  PrintExpr(Node->getCommon());
1397  OS << " ?: ";
1398  PrintExpr(Node->getFalseExpr());
1399 }
1400 
1401 void StmtPrinter::VisitAddrLabelExpr(AddrLabelExpr *Node) {
1402  OS << "&&" << Node->getLabel()->getName();
1403 }
1404 
1405 void StmtPrinter::VisitStmtExpr(StmtExpr *E) {
1406  OS << "(";
1407  PrintRawCompoundStmt(E->getSubStmt());
1408  OS << ")";
1409 }
1410 
1411 void StmtPrinter::VisitChooseExpr(ChooseExpr *Node) {
1412  OS << "__builtin_choose_expr(";
1413  PrintExpr(Node->getCond());
1414  OS << ", ";
1415  PrintExpr(Node->getLHS());
1416  OS << ", ";
1417  PrintExpr(Node->getRHS());
1418  OS << ")";
1419 }
1420 
1421 void StmtPrinter::VisitGNUNullExpr(GNUNullExpr *) {
1422  OS << "__null";
1423 }
1424 
1425 void StmtPrinter::VisitShuffleVectorExpr(ShuffleVectorExpr *Node) {
1426  OS << "__builtin_shufflevector(";
1427  for (unsigned i = 0, e = Node->getNumSubExprs(); i != e; ++i) {
1428  if (i) OS << ", ";
1429  PrintExpr(Node->getExpr(i));
1430  }
1431  OS << ")";
1432 }
1433 
1434 void StmtPrinter::VisitConvertVectorExpr(ConvertVectorExpr *Node) {
1435  OS << "__builtin_convertvector(";
1436  PrintExpr(Node->getSrcExpr());
1437  OS << ", ";
1438  Node->getType().print(OS, Policy);
1439  OS << ")";
1440 }
1441 
1442 void StmtPrinter::VisitInitListExpr(InitListExpr* Node) {
1443  if (Node->getSyntacticForm()) {
1444  Visit(Node->getSyntacticForm());
1445  return;
1446  }
1447 
1448  OS << "{";
1449  for (unsigned i = 0, e = Node->getNumInits(); i != e; ++i) {
1450  if (i) OS << ", ";
1451  if (Node->getInit(i))
1452  PrintExpr(Node->getInit(i));
1453  else
1454  OS << "{}";
1455  }
1456  OS << "}";
1457 }
1458 
1459 void StmtPrinter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *Node) {
1460  // There's no way to express this expression in any of our supported
1461  // languages, so just emit something terse and (hopefully) clear.
1462  OS << "{";
1463  PrintExpr(Node->getSubExpr());
1464  OS << "}";
1465 }
1466 
1467 void StmtPrinter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *Node) {
1468  OS << "*";
1469 }
1470 
1471 void StmtPrinter::VisitParenListExpr(ParenListExpr* Node) {
1472  OS << "(";
1473  for (unsigned i = 0, e = Node->getNumExprs(); i != e; ++i) {
1474  if (i) OS << ", ";
1475  PrintExpr(Node->getExpr(i));
1476  }
1477  OS << ")";
1478 }
1479 
1480 void StmtPrinter::VisitDesignatedInitExpr(DesignatedInitExpr *Node) {
1481  bool NeedsEquals = true;
1482  for (const DesignatedInitExpr::Designator &D : Node->designators()) {
1483  if (D.isFieldDesignator()) {
1484  if (D.getDotLoc().isInvalid()) {
1485  if (IdentifierInfo *II = D.getFieldName()) {
1486  OS << II->getName() << ":";
1487  NeedsEquals = false;
1488  }
1489  } else {
1490  OS << "." << D.getFieldName()->getName();
1491  }
1492  } else {
1493  OS << "[";
1494  if (D.isArrayDesignator()) {
1495  PrintExpr(Node->getArrayIndex(D));
1496  } else {
1497  PrintExpr(Node->getArrayRangeStart(D));
1498  OS << " ... ";
1499  PrintExpr(Node->getArrayRangeEnd(D));
1500  }
1501  OS << "]";
1502  }
1503  }
1504 
1505  if (NeedsEquals)
1506  OS << " = ";
1507  else
1508  OS << " ";
1509  PrintExpr(Node->getInit());
1510 }
1511 
1512 void StmtPrinter::VisitDesignatedInitUpdateExpr(
1513  DesignatedInitUpdateExpr *Node) {
1514  OS << "{";
1515  OS << "/*base*/";
1516  PrintExpr(Node->getBase());
1517  OS << ", ";
1518 
1519  OS << "/*updater*/";
1520  PrintExpr(Node->getUpdater());
1521  OS << "}";
1522 }
1523 
1524 void StmtPrinter::VisitNoInitExpr(NoInitExpr *Node) {
1525  OS << "/*no init*/";
1526 }
1527 
1528 void StmtPrinter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *Node) {
1529  if (Node->getType()->getAsCXXRecordDecl()) {
1530  OS << "/*implicit*/";
1531  Node->getType().print(OS, Policy);
1532  OS << "()";
1533  } else {
1534  OS << "/*implicit*/(";
1535  Node->getType().print(OS, Policy);
1536  OS << ')';
1537  if (Node->getType()->isRecordType())
1538  OS << "{}";
1539  else
1540  OS << 0;
1541  }
1542 }
1543 
1544 void StmtPrinter::VisitVAArgExpr(VAArgExpr *Node) {
1545  OS << "__builtin_va_arg(";
1546  PrintExpr(Node->getSubExpr());
1547  OS << ", ";
1548  Node->getType().print(OS, Policy);
1549  OS << ")";
1550 }
1551 
1552 void StmtPrinter::VisitPseudoObjectExpr(PseudoObjectExpr *Node) {
1553  PrintExpr(Node->getSyntacticForm());
1554 }
1555 
1556 void StmtPrinter::VisitAtomicExpr(AtomicExpr *Node) {
1557  const char *Name = nullptr;
1558  switch (Node->getOp()) {
1559 #define BUILTIN(ID, TYPE, ATTRS)
1560 #define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \
1561  case AtomicExpr::AO ## ID: \
1562  Name = #ID "("; \
1563  break;
1564 #include "clang/Basic/Builtins.def"
1565  }
1566  OS << Name;
1567 
1568  // AtomicExpr stores its subexpressions in a permuted order.
1569  PrintExpr(Node->getPtr());
1570  if (Node->getOp() != AtomicExpr::AO__c11_atomic_load &&
1571  Node->getOp() != AtomicExpr::AO__atomic_load_n &&
1572  Node->getOp() != AtomicExpr::AO__opencl_atomic_load) {
1573  OS << ", ";
1574  PrintExpr(Node->getVal1());
1575  }
1576  if (Node->getOp() == AtomicExpr::AO__atomic_exchange ||
1577  Node->isCmpXChg()) {
1578  OS << ", ";
1579  PrintExpr(Node->getVal2());
1580  }
1581  if (Node->getOp() == AtomicExpr::AO__atomic_compare_exchange ||
1582  Node->getOp() == AtomicExpr::AO__atomic_compare_exchange_n) {
1583  OS << ", ";
1584  PrintExpr(Node->getWeak());
1585  }
1586  if (Node->getOp() != AtomicExpr::AO__c11_atomic_init &&
1587  Node->getOp() != AtomicExpr::AO__opencl_atomic_init) {
1588  OS << ", ";
1589  PrintExpr(Node->getOrder());
1590  }
1591  if (Node->isCmpXChg()) {
1592  OS << ", ";
1593  PrintExpr(Node->getOrderFail());
1594  }
1595  OS << ")";
1596 }
1597 
1598 // C++
1599 void StmtPrinter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *Node) {
1600  const char *OpStrings[NUM_OVERLOADED_OPERATORS] = {
1601  "",
1602 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
1603  Spelling,
1604 #include "clang/Basic/OperatorKinds.def"
1605  };
1606 
1608  if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
1609  if (Node->getNumArgs() == 1) {
1610  OS << OpStrings[Kind] << ' ';
1611  PrintExpr(Node->getArg(0));
1612  } else {
1613  PrintExpr(Node->getArg(0));
1614  OS << ' ' << OpStrings[Kind];
1615  }
1616  } else if (Kind == OO_Arrow) {
1617  PrintExpr(Node->getArg(0));
1618  } else if (Kind == OO_Call) {
1619  PrintExpr(Node->getArg(0));
1620  OS << '(';
1621  for (unsigned ArgIdx = 1; ArgIdx < Node->getNumArgs(); ++ArgIdx) {
1622  if (ArgIdx > 1)
1623  OS << ", ";
1624  if (!isa<CXXDefaultArgExpr>(Node->getArg(ArgIdx)))
1625  PrintExpr(Node->getArg(ArgIdx));
1626  }
1627  OS << ')';
1628  } else if (Kind == OO_Subscript) {
1629  PrintExpr(Node->getArg(0));
1630  OS << '[';
1631  PrintExpr(Node->getArg(1));
1632  OS << ']';
1633  } else if (Node->getNumArgs() == 1) {
1634  OS << OpStrings[Kind] << ' ';
1635  PrintExpr(Node->getArg(0));
1636  } else if (Node->getNumArgs() == 2) {
1637  PrintExpr(Node->getArg(0));
1638  OS << ' ' << OpStrings[Kind] << ' ';
1639  PrintExpr(Node->getArg(1));
1640  } else {
1641  llvm_unreachable("unknown overloaded operator");
1642  }
1643 }
1644 
1645 void StmtPrinter::VisitCXXMemberCallExpr(CXXMemberCallExpr *Node) {
1646  // If we have a conversion operator call only print the argument.
1647  CXXMethodDecl *MD = Node->getMethodDecl();
1648  if (MD && isa<CXXConversionDecl>(MD)) {
1649  PrintExpr(Node->getImplicitObjectArgument());
1650  return;
1651  }
1652  VisitCallExpr(cast<CallExpr>(Node));
1653 }
1654 
1655 void StmtPrinter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *Node) {
1656  PrintExpr(Node->getCallee());
1657  OS << "<<<";
1658  PrintCallArgs(Node->getConfig());
1659  OS << ">>>(";
1660  PrintCallArgs(Node);
1661  OS << ")";
1662 }
1663 
1664 void StmtPrinter::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) {
1665  OS << Node->getCastName() << '<';
1666  Node->getTypeAsWritten().print(OS, Policy);
1667  OS << ">(";
1668  PrintExpr(Node->getSubExpr());
1669  OS << ")";
1670 }
1671 
1672 void StmtPrinter::VisitCXXStaticCastExpr(CXXStaticCastExpr *Node) {
1673  VisitCXXNamedCastExpr(Node);
1674 }
1675 
1676 void StmtPrinter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *Node) {
1677  VisitCXXNamedCastExpr(Node);
1678 }
1679 
1680 void StmtPrinter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *Node) {
1681  VisitCXXNamedCastExpr(Node);
1682 }
1683 
1684 void StmtPrinter::VisitCXXConstCastExpr(CXXConstCastExpr *Node) {
1685  VisitCXXNamedCastExpr(Node);
1686 }
1687 
1688 void StmtPrinter::VisitCXXTypeidExpr(CXXTypeidExpr *Node) {
1689  OS << "typeid(";
1690  if (Node->isTypeOperand()) {
1691  Node->getTypeOperandSourceInfo()->getType().print(OS, Policy);
1692  } else {
1693  PrintExpr(Node->getExprOperand());
1694  }
1695  OS << ")";
1696 }
1697 
1698 void StmtPrinter::VisitCXXUuidofExpr(CXXUuidofExpr *Node) {
1699  OS << "__uuidof(";
1700  if (Node->isTypeOperand()) {
1701  Node->getTypeOperandSourceInfo()->getType().print(OS, Policy);
1702  } else {
1703  PrintExpr(Node->getExprOperand());
1704  }
1705  OS << ")";
1706 }
1707 
1708 void StmtPrinter::VisitMSPropertyRefExpr(MSPropertyRefExpr *Node) {
1709  PrintExpr(Node->getBaseExpr());
1710  if (Node->isArrow())
1711  OS << "->";
1712  else
1713  OS << ".";
1714  if (NestedNameSpecifier *Qualifier =
1716  Qualifier->print(OS, Policy);
1717  OS << Node->getPropertyDecl()->getDeclName();
1718 }
1719 
1720 void StmtPrinter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *Node) {
1721  PrintExpr(Node->getBase());
1722  OS << "[";
1723  PrintExpr(Node->getIdx());
1724  OS << "]";
1725 }
1726 
1727 void StmtPrinter::VisitUserDefinedLiteral(UserDefinedLiteral *Node) {
1728  switch (Node->getLiteralOperatorKind()) {
1730  OS << cast<StringLiteral>(Node->getArg(0)->IgnoreImpCasts())->getString();
1731  break;
1733  const auto *DRE = cast<DeclRefExpr>(Node->getCallee()->IgnoreImpCasts());
1734  const TemplateArgumentList *Args =
1735  cast<FunctionDecl>(DRE->getDecl())->getTemplateSpecializationArgs();
1736  assert(Args);
1737 
1738  if (Args->size() != 1) {
1739  OS << "operator\"\"" << Node->getUDSuffix()->getName();
1740  printTemplateArgumentList(OS, Args->asArray(), Policy);
1741  OS << "()";
1742  return;
1743  }
1744 
1745  const TemplateArgument &Pack = Args->get(0);
1746  for (const auto &P : Pack.pack_elements()) {
1747  char C = (char)P.getAsIntegral().getZExtValue();
1748  OS << C;
1749  }
1750  break;
1751  }
1753  // Print integer literal without suffix.
1754  const auto *Int = cast<IntegerLiteral>(Node->getCookedLiteral());
1755  OS << Int->getValue().toString(10, /*isSigned*/false);
1756  break;
1757  }
1759  // Print floating literal without suffix.
1760  auto *Float = cast<FloatingLiteral>(Node->getCookedLiteral());
1761  PrintFloatingLiteral(OS, Float, /*PrintSuffix=*/false);
1762  break;
1763  }
1766  PrintExpr(Node->getCookedLiteral());
1767  break;
1768  }
1769  OS << Node->getUDSuffix()->getName();
1770 }
1771 
1772 void StmtPrinter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) {
1773  OS << (Node->getValue() ? "true" : "false");
1774 }
1775 
1776 void StmtPrinter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *Node) {
1777  OS << "nullptr";
1778 }
1779 
1780 void StmtPrinter::VisitCXXThisExpr(CXXThisExpr *Node) {
1781  OS << "this";
1782 }
1783 
1784 void StmtPrinter::VisitCXXThrowExpr(CXXThrowExpr *Node) {
1785  if (!Node->getSubExpr())
1786  OS << "throw";
1787  else {
1788  OS << "throw ";
1789  PrintExpr(Node->getSubExpr());
1790  }
1791 }
1792 
1793 void StmtPrinter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *Node) {
1794  // Nothing to print: we picked up the default argument.
1795 }
1796 
1797 void StmtPrinter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *Node) {
1798  // Nothing to print: we picked up the default initializer.
1799 }
1800 
1801 void StmtPrinter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) {
1802  Node->getType().print(OS, Policy);
1803  // If there are no parens, this is list-initialization, and the braces are
1804  // part of the syntax of the inner construct.
1805  if (Node->getLParenLoc().isValid())
1806  OS << "(";
1807  PrintExpr(Node->getSubExpr());
1808  if (Node->getLParenLoc().isValid())
1809  OS << ")";
1810 }
1811 
1812 void StmtPrinter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node) {
1813  PrintExpr(Node->getSubExpr());
1814 }
1815 
1816 void StmtPrinter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *Node) {
1817  Node->getType().print(OS, Policy);
1818  if (Node->isStdInitListInitialization())
1819  /* Nothing to do; braces are part of creating the std::initializer_list. */;
1820  else if (Node->isListInitialization())
1821  OS << "{";
1822  else
1823  OS << "(";
1825  ArgEnd = Node->arg_end();
1826  Arg != ArgEnd; ++Arg) {
1827  if ((*Arg)->isDefaultArgument())
1828  break;
1829  if (Arg != Node->arg_begin())
1830  OS << ", ";
1831  PrintExpr(*Arg);
1832  }
1833  if (Node->isStdInitListInitialization())
1834  /* See above. */;
1835  else if (Node->isListInitialization())
1836  OS << "}";
1837  else
1838  OS << ")";
1839 }
1840 
1841 void StmtPrinter::VisitLambdaExpr(LambdaExpr *Node) {
1842  OS << '[';
1843  bool NeedComma = false;
1844  switch (Node->getCaptureDefault()) {
1845  case LCD_None:
1846  break;
1847 
1848  case LCD_ByCopy:
1849  OS << '=';
1850  NeedComma = true;
1851  break;
1852 
1853  case LCD_ByRef:
1854  OS << '&';
1855  NeedComma = true;
1856  break;
1857  }
1859  CEnd = Node->explicit_capture_end();
1860  C != CEnd;
1861  ++C) {
1862  if (C->capturesVLAType())
1863  continue;
1864 
1865  if (NeedComma)
1866  OS << ", ";
1867  NeedComma = true;
1868 
1869  switch (C->getCaptureKind()) {
1870  case LCK_This:
1871  OS << "this";
1872  break;
1873 
1874  case LCK_StarThis:
1875  OS << "*this";
1876  break;
1877 
1878  case LCK_ByRef:
1879  if (Node->getCaptureDefault() != LCD_ByRef || Node->isInitCapture(C))
1880  OS << '&';
1881  OS << C->getCapturedVar()->getName();
1882  break;
1883 
1884  case LCK_ByCopy:
1885  OS << C->getCapturedVar()->getName();
1886  break;
1887 
1888  case LCK_VLAType:
1889  llvm_unreachable("VLA type in explicit captures.");
1890  }
1891 
1892  if (Node->isInitCapture(C))
1893  PrintExpr(C->getCapturedVar()->getInit());
1894  }
1895  OS << ']';
1896 
1897  if (Node->hasExplicitParameters()) {
1898  OS << " (";
1899  CXXMethodDecl *Method = Node->getCallOperator();
1900  NeedComma = false;
1901  for (const auto *P : Method->parameters()) {
1902  if (NeedComma) {
1903  OS << ", ";
1904  } else {
1905  NeedComma = true;
1906  }
1907  std::string ParamStr = P->getNameAsString();
1908  P->getOriginalType().print(OS, Policy, ParamStr);
1909  }
1910  if (Method->isVariadic()) {
1911  if (NeedComma)
1912  OS << ", ";
1913  OS << "...";
1914  }
1915  OS << ')';
1916 
1917  if (Node->isMutable())
1918  OS << " mutable";
1919 
1920  auto *Proto = Method->getType()->getAs<FunctionProtoType>();
1921  Proto->printExceptionSpecification(OS, Policy);
1922 
1923  // FIXME: Attributes
1924 
1925  // Print the trailing return type if it was specified in the source.
1926  if (Node->hasExplicitResultType()) {
1927  OS << " -> ";
1928  Proto->getReturnType().print(OS, Policy);
1929  }
1930  }
1931 
1932  // Print the body.
1933  CompoundStmt *Body = Node->getBody();
1934  OS << ' ';
1935  PrintStmt(Body);
1936 }
1937 
1938 void StmtPrinter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *Node) {
1939  if (TypeSourceInfo *TSInfo = Node->getTypeSourceInfo())
1940  TSInfo->getType().print(OS, Policy);
1941  else
1942  Node->getType().print(OS, Policy);
1943  OS << "()";
1944 }
1945 
1946 void StmtPrinter::VisitCXXNewExpr(CXXNewExpr *E) {
1947  if (E->isGlobalNew())
1948  OS << "::";
1949  OS << "new ";
1950  unsigned NumPlace = E->getNumPlacementArgs();
1951  if (NumPlace > 0 && !isa<CXXDefaultArgExpr>(E->getPlacementArg(0))) {
1952  OS << "(";
1953  PrintExpr(E->getPlacementArg(0));
1954  for (unsigned i = 1; i < NumPlace; ++i) {
1955  if (isa<CXXDefaultArgExpr>(E->getPlacementArg(i)))
1956  break;
1957  OS << ", ";
1958  PrintExpr(E->getPlacementArg(i));
1959  }
1960  OS << ") ";
1961  }
1962  if (E->isParenTypeId())
1963  OS << "(";
1964  std::string TypeS;
1965  if (Expr *Size = E->getArraySize()) {
1966  llvm::raw_string_ostream s(TypeS);
1967  s << '[';
1968  Size->printPretty(s, Helper, Policy);
1969  s << ']';
1970  }
1971  E->getAllocatedType().print(OS, Policy, TypeS);
1972  if (E->isParenTypeId())
1973  OS << ")";
1974 
1976  if (InitStyle) {
1977  if (InitStyle == CXXNewExpr::CallInit)
1978  OS << "(";
1979  PrintExpr(E->getInitializer());
1980  if (InitStyle == CXXNewExpr::CallInit)
1981  OS << ")";
1982  }
1983 }
1984 
1985 void StmtPrinter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1986  if (E->isGlobalDelete())
1987  OS << "::";
1988  OS << "delete ";
1989  if (E->isArrayForm())
1990  OS << "[] ";
1991  PrintExpr(E->getArgument());
1992 }
1993 
1994 void StmtPrinter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1995  PrintExpr(E->getBase());
1996  if (E->isArrow())
1997  OS << "->";
1998  else
1999  OS << '.';
2000  if (E->getQualifier())
2001  E->getQualifier()->print(OS, Policy);
2002  OS << "~";
2003 
2005  OS << II->getName();
2006  else
2007  E->getDestroyedType().print(OS, Policy);
2008 }
2009 
2010 void StmtPrinter::VisitCXXConstructExpr(CXXConstructExpr *E) {
2012  OS << "{";
2013 
2014  for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) {
2015  if (isa<CXXDefaultArgExpr>(E->getArg(i))) {
2016  // Don't print any defaulted arguments
2017  break;
2018  }
2019 
2020  if (i) OS << ", ";
2021  PrintExpr(E->getArg(i));
2022  }
2023 
2025  OS << "}";
2026 }
2027 
2028 void StmtPrinter::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
2029  // Parens are printed by the surrounding context.
2030  OS << "<forwarded>";
2031 }
2032 
2033 void StmtPrinter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
2034  PrintExpr(E->getSubExpr());
2035 }
2036 
2037 void StmtPrinter::VisitExprWithCleanups(ExprWithCleanups *E) {
2038  // Just forward to the subexpression.
2039  PrintExpr(E->getSubExpr());
2040 }
2041 
2042 void
2043 StmtPrinter::VisitCXXUnresolvedConstructExpr(
2045  Node->getTypeAsWritten().print(OS, Policy);
2046  OS << "(";
2048  ArgEnd = Node->arg_end();
2049  Arg != ArgEnd; ++Arg) {
2050  if (Arg != Node->arg_begin())
2051  OS << ", ";
2052  PrintExpr(*Arg);
2053  }
2054  OS << ")";
2055 }
2056 
2057 void StmtPrinter::VisitCXXDependentScopeMemberExpr(
2059  if (!Node->isImplicitAccess()) {
2060  PrintExpr(Node->getBase());
2061  OS << (Node->isArrow() ? "->" : ".");
2062  }
2063  if (NestedNameSpecifier *Qualifier = Node->getQualifier())
2064  Qualifier->print(OS, Policy);
2065  if (Node->hasTemplateKeyword())
2066  OS << "template ";
2067  OS << Node->getMemberNameInfo();
2068  if (Node->hasExplicitTemplateArgs())
2069  printTemplateArgumentList(OS, Node->template_arguments(), Policy);
2070 }
2071 
2072 void StmtPrinter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *Node) {
2073  if (!Node->isImplicitAccess()) {
2074  PrintExpr(Node->getBase());
2075  OS << (Node->isArrow() ? "->" : ".");
2076  }
2077  if (NestedNameSpecifier *Qualifier = Node->getQualifier())
2078  Qualifier->print(OS, Policy);
2079  if (Node->hasTemplateKeyword())
2080  OS << "template ";
2081  OS << Node->getMemberNameInfo();
2082  if (Node->hasExplicitTemplateArgs())
2083  printTemplateArgumentList(OS, Node->template_arguments(), Policy);
2084 }
2085 
2086 static const char *getTypeTraitName(TypeTrait TT) {
2087  switch (TT) {
2088 #define TYPE_TRAIT_1(Spelling, Name, Key) \
2089 case clang::UTT_##Name: return #Spelling;
2090 #define TYPE_TRAIT_2(Spelling, Name, Key) \
2091 case clang::BTT_##Name: return #Spelling;
2092 #define TYPE_TRAIT_N(Spelling, Name, Key) \
2093  case clang::TT_##Name: return #Spelling;
2094 #include "clang/Basic/TokenKinds.def"
2095  }
2096  llvm_unreachable("Type trait not covered by switch");
2097 }
2098 
2099 static const char *getTypeTraitName(ArrayTypeTrait ATT) {
2100  switch (ATT) {
2101  case ATT_ArrayRank: return "__array_rank";
2102  case ATT_ArrayExtent: return "__array_extent";
2103  }
2104  llvm_unreachable("Array type trait not covered by switch");
2105 }
2106 
2107 static const char *getExpressionTraitName(ExpressionTrait ET) {
2108  switch (ET) {
2109  case ET_IsLValueExpr: return "__is_lvalue_expr";
2110  case ET_IsRValueExpr: return "__is_rvalue_expr";
2111  }
2112  llvm_unreachable("Expression type trait not covered by switch");
2113 }
2114 
2115 void StmtPrinter::VisitTypeTraitExpr(TypeTraitExpr *E) {
2116  OS << getTypeTraitName(E->getTrait()) << "(";
2117  for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
2118  if (I > 0)
2119  OS << ", ";
2120  E->getArg(I)->getType().print(OS, Policy);
2121  }
2122  OS << ")";
2123 }
2124 
2125 void StmtPrinter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
2126  OS << getTypeTraitName(E->getTrait()) << '(';
2127  E->getQueriedType().print(OS, Policy);
2128  OS << ')';
2129 }
2130 
2131 void StmtPrinter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
2132  OS << getExpressionTraitName(E->getTrait()) << '(';
2133  PrintExpr(E->getQueriedExpression());
2134  OS << ')';
2135 }
2136 
2137 void StmtPrinter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
2138  OS << "noexcept(";
2139  PrintExpr(E->getOperand());
2140  OS << ")";
2141 }
2142 
2143 void StmtPrinter::VisitPackExpansionExpr(PackExpansionExpr *E) {
2144  PrintExpr(E->getPattern());
2145  OS << "...";
2146 }
2147 
2148 void StmtPrinter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
2149  OS << "sizeof...(" << *E->getPack() << ")";
2150 }
2151 
2152 void StmtPrinter::VisitSubstNonTypeTemplateParmPackExpr(
2154  OS << *Node->getParameterPack();
2155 }
2156 
2157 void StmtPrinter::VisitSubstNonTypeTemplateParmExpr(
2159  Visit(Node->getReplacement());
2160 }
2161 
2162 void StmtPrinter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
2163  OS << *E->getParameterPack();
2164 }
2165 
2166 void StmtPrinter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *Node){
2167  PrintExpr(Node->GetTemporaryExpr());
2168 }
2169 
2170 void StmtPrinter::VisitCXXFoldExpr(CXXFoldExpr *E) {
2171  OS << "(";
2172  if (E->getLHS()) {
2173  PrintExpr(E->getLHS());
2174  OS << " " << BinaryOperator::getOpcodeStr(E->getOperator()) << " ";
2175  }
2176  OS << "...";
2177  if (E->getRHS()) {
2178  OS << " " << BinaryOperator::getOpcodeStr(E->getOperator()) << " ";
2179  PrintExpr(E->getRHS());
2180  }
2181  OS << ")";
2182 }
2183 
2184 // C++ Coroutines TS
2185 
2186 void StmtPrinter::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
2187  Visit(S->getBody());
2188 }
2189 
2190 void StmtPrinter::VisitCoreturnStmt(CoreturnStmt *S) {
2191  OS << "co_return";
2192  if (S->getOperand()) {
2193  OS << " ";
2194  Visit(S->getOperand());
2195  }
2196  OS << ";";
2197 }
2198 
2199 void StmtPrinter::VisitCoawaitExpr(CoawaitExpr *S) {
2200  OS << "co_await ";
2201  PrintExpr(S->getOperand());
2202 }
2203 
2204 void StmtPrinter::VisitDependentCoawaitExpr(DependentCoawaitExpr *S) {
2205  OS << "co_await ";
2206  PrintExpr(S->getOperand());
2207 }
2208 
2209 void StmtPrinter::VisitCoyieldExpr(CoyieldExpr *S) {
2210  OS << "co_yield ";
2211  PrintExpr(S->getOperand());
2212 }
2213 
2214 // Obj-C
2215 
2216 void StmtPrinter::VisitObjCStringLiteral(ObjCStringLiteral *Node) {
2217  OS << "@";
2218  VisitStringLiteral(Node->getString());
2219 }
2220 
2221 void StmtPrinter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
2222  OS << "@";
2223  Visit(E->getSubExpr());
2224 }
2225 
2226 void StmtPrinter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
2227  OS << "@[ ";
2229  for (auto I = Ch.begin(), E = Ch.end(); I != E; ++I) {
2230  if (I != Ch.begin())
2231  OS << ", ";
2232  Visit(*I);
2233  }
2234  OS << " ]";
2235 }
2236 
2237 void StmtPrinter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
2238  OS << "@{ ";
2239  for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
2240  if (I > 0)
2241  OS << ", ";
2242 
2243  ObjCDictionaryElement Element = E->getKeyValueElement(I);
2244  Visit(Element.Key);
2245  OS << " : ";
2246  Visit(Element.Value);
2247  if (Element.isPackExpansion())
2248  OS << "...";
2249  }
2250  OS << " }";
2251 }
2252 
2253 void StmtPrinter::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) {
2254  OS << "@encode(";
2255  Node->getEncodedType().print(OS, Policy);
2256  OS << ')';
2257 }
2258 
2259 void StmtPrinter::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) {
2260  OS << "@selector(";
2261  Node->getSelector().print(OS);
2262  OS << ')';
2263 }
2264 
2265 void StmtPrinter::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) {
2266  OS << "@protocol(" << *Node->getProtocol() << ')';
2267 }
2268 
2269 void StmtPrinter::VisitObjCMessageExpr(ObjCMessageExpr *Mess) {
2270  OS << "[";
2271  switch (Mess->getReceiverKind()) {
2273  PrintExpr(Mess->getInstanceReceiver());
2274  break;
2275 
2277  Mess->getClassReceiver().print(OS, Policy);
2278  break;
2279 
2282  OS << "Super";
2283  break;
2284  }
2285 
2286  OS << ' ';
2287  Selector selector = Mess->getSelector();
2288  if (selector.isUnarySelector()) {
2289  OS << selector.getNameForSlot(0);
2290  } else {
2291  for (unsigned i = 0, e = Mess->getNumArgs(); i != e; ++i) {
2292  if (i < selector.getNumArgs()) {
2293  if (i > 0) OS << ' ';
2294  if (selector.getIdentifierInfoForSlot(i))
2295  OS << selector.getIdentifierInfoForSlot(i)->getName() << ':';
2296  else
2297  OS << ":";
2298  }
2299  else OS << ", "; // Handle variadic methods.
2300 
2301  PrintExpr(Mess->getArg(i));
2302  }
2303  }
2304  OS << "]";
2305 }
2306 
2307 void StmtPrinter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *Node) {
2308  OS << (Node->getValue() ? "__objc_yes" : "__objc_no");
2309 }
2310 
2311 void
2312 StmtPrinter::VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
2313  PrintExpr(E->getSubExpr());
2314 }
2315 
2316 void
2317 StmtPrinter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
2318  OS << '(' << E->getBridgeKindName();
2319  E->getType().print(OS, Policy);
2320  OS << ')';
2321  PrintExpr(E->getSubExpr());
2322 }
2323 
2324 void StmtPrinter::VisitBlockExpr(BlockExpr *Node) {
2325  BlockDecl *BD = Node->getBlockDecl();
2326  OS << "^";
2327 
2328  const FunctionType *AFT = Node->getFunctionType();
2329 
2330  if (isa<FunctionNoProtoType>(AFT)) {
2331  OS << "()";
2332  } else if (!BD->param_empty() || cast<FunctionProtoType>(AFT)->isVariadic()) {
2333  OS << '(';
2334  for (BlockDecl::param_iterator AI = BD->param_begin(),
2335  E = BD->param_end(); AI != E; ++AI) {
2336  if (AI != BD->param_begin()) OS << ", ";
2337  std::string ParamStr = (*AI)->getNameAsString();
2338  (*AI)->getType().print(OS, Policy, ParamStr);
2339  }
2340 
2341  const auto *FT = cast<FunctionProtoType>(AFT);
2342  if (FT->isVariadic()) {
2343  if (!BD->param_empty()) OS << ", ";
2344  OS << "...";
2345  }
2346  OS << ')';
2347  }
2348  OS << "{ }";
2349 }
2350 
2351 void StmtPrinter::VisitOpaqueValueExpr(OpaqueValueExpr *Node) {
2352  PrintExpr(Node->getSourceExpr());
2353 }
2354 
2355 void StmtPrinter::VisitTypoExpr(TypoExpr *Node) {
2356  // TODO: Print something reasonable for a TypoExpr, if necessary.
2357  llvm_unreachable("Cannot print TypoExpr nodes");
2358 }
2359 
2360 void StmtPrinter::VisitAsTypeExpr(AsTypeExpr *Node) {
2361  OS << "__builtin_astype(";
2362  PrintExpr(Node->getSrcExpr());
2363  OS << ", ";
2364  Node->getType().print(OS, Policy);
2365  OS << ")";
2366 }
2367 
2368 //===----------------------------------------------------------------------===//
2369 // Stmt method implementations
2370 //===----------------------------------------------------------------------===//
2371 
2372 void Stmt::dumpPretty(const ASTContext &Context) const {
2373  printPretty(llvm::errs(), nullptr, PrintingPolicy(Context.getLangOpts()));
2374 }
2375 
2376 void Stmt::printPretty(raw_ostream &OS, PrinterHelper *Helper,
2377  const PrintingPolicy &Policy, unsigned Indentation,
2378  StringRef NL,
2379  const ASTContext *Context) const {
2380  StmtPrinter P(OS, Helper, Policy, Indentation, NL, Context);
2381  P.Visit(const_cast<Stmt*>(this));
2382 }
2383 
2384 //===----------------------------------------------------------------------===//
2385 // PrinterHelper
2386 //===----------------------------------------------------------------------===//
2387 
2388 // Implement virtual destructor.
2389 PrinterHelper::~PrinterHelper() = default;
Expr * getInc()
Definition: Stmt.h:1268
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
Definition: ExprObjC.h:577
ObjCIndirectCopyRestoreExpr - Represents the passing of a function argument by indirect copy-restore ...
Definition: ExprObjC.h:1518
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:78
The receiver is the instance of the superclass object.
Definition: ExprObjC.h:1061
ExprIterator arg_iterator
Definition: ExprCXX.h:1366
Represents a single C99 designator.
Definition: Expr.h:4309
Raw form: operator "" X (const char *)
Definition: ExprCXX.h:497
Expr * getVal2() const
Definition: Expr.h:5287
Defines the clang::ASTContext interface.
const BlockDecl * getBlockDecl() const
Definition: Expr.h:4993
This represents &#39;#pragma omp distribute simd&#39; composite directive.
Definition: StmtOpenMP.h:3214
This represents &#39;#pragma omp master&#39; directive.
Definition: StmtOpenMP.h:1397
operator "" X (long double)
Definition: ExprCXX.h:506
TypeSourceInfo * getTypeOperandSourceInfo() const
Retrieve source information for the type operand.
Definition: ExprCXX.h:913
The null pointer literal (C++11 [lex.nullptr])
Definition: ExprCXX.h:585
capture_iterator explicit_capture_end() const
Retrieve an iterator pointing past the end of the sequence of explicit lambda captures.
Definition: ExprCXX.cpp:992
This represents &#39;#pragma omp task&#39; directive.
Definition: StmtOpenMP.h:1737
This represents a GCC inline-assembly statement extension.
Definition: Stmt.h:1647
Represents a &#39;co_await&#39; expression while the type of the promise is dependent.
Definition: ExprCXX.h:4376
Expr * getArrayIndex(const Designator &D) const
Definition: Expr.cpp:3890
bool getValue() const
Definition: ExprObjC.h:94
The receiver is an object instance.
Definition: ExprObjC.h:1055
Expr * getLHS() const
Definition: Expr.h:3442
bool hasExplicitTemplateArgs() const
Determines whether this expression had explicit template arguments.
Definition: ExprCXX.h:2727
const Stmt * getElse() const
Definition: Stmt.h:999
unsigned getNumInputs() const
Definition: Stmt.h:1563
Expr * getSyntacticForm()
Return the syntactic form of this expression, i.e.
Definition: Expr.h:5145
bool hasTemplateKeyword() const
Determines whether the name was preceded by the template keyword.
Definition: ExprCXX.h:2971
bool hasTemplateKeyword() const
Determines whether the member name was preceded by the template keyword.
Definition: Expr.h:2623
ObjCDictionaryElement getKeyValueElement(unsigned Index) const
Definition: ExprObjC.h:344
const FunctionProtoType * getFunctionType() const
getFunctionType - Return the underlying function type for this block.
Definition: Expr.cpp:2081
CompoundStmt * getBlock() const
Definition: Stmt.h:1982
Smart pointer class that efficiently represents Objective-C method names.
A (possibly-)qualified type.
Definition: Type.h:642
ArrayRef< TemplateArgumentLoc > template_arguments() const
Definition: ExprCXX.h:2998
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2568
ArrayRef< OMPClause * > clauses()
Definition: StmtOpenMP.h:260
unsigned SuppressInitializers
Suppress printing of variable initializers.
Expr * getCond() const
Definition: Expr.h:3837
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2359
Selector getSelector() const
Definition: ExprObjC.cpp:312
Defines enumerations for the type traits support.
const Expr * getSubExpr() const
Definition: ExprCXX.h:1028
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
Definition: Type.h:985
Expr * getCond()
Definition: Stmt.h:1158
Expr * getExpr(unsigned Index)
getExpr - Return the Expr at the specified index.
Definition: Expr.h:3701
unsigned getNumSubExprs() const
getNumSubExprs - Return the size of the SubExprs array.
Definition: Expr.h:3695
bool isSuperReceiver() const
Definition: ExprObjC.h:739
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
Definition: ExprCXX.h:2372
CompoundStmt * getSubStmt()
Definition: Expr.h:3632
const Expr * getInit(unsigned Init) const
Definition: Expr.h:4048
bool hasExplicitResultType() const
Whether this lambda had its result type explicitly specified.
Definition: ExprCXX.h:1813
ObjCProtocolDecl * getProtocol() const
Definition: ExprObjC.h:490
Represents a &#39;co_return&#39; statement in the C++ Coroutines TS.
Definition: StmtCXX.h:435
Stmt - This represents one statement.
Definition: Stmt.h:66
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition: Expr.h:2347
const ObjCAtFinallyStmt * getFinallyStmt() const
Retrieve the @finally statement, if any.
Definition: StmtObjC.h:224
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3351
CXXCatchStmt * getHandler(unsigned i)
Definition: StmtCXX.h:104
IfStmt - This represents an if/then/else.
Definition: Stmt.h:959
C Language Family Type Representation.
bool param_empty() const
Definition: Decl.h:3947
unsigned getNumOutputs() const
Definition: Stmt.h:1541
static CharSourceRange getTokenRange(SourceRange R)
This represents &#39;#pragma omp for simd&#39; directive.
Definition: StmtOpenMP.h:1147
bool isRecordType() const
Definition: Type.h:6343
Expr * getBase() const
Definition: Expr.h:2562
const StringLiteral * getAsmString() const
Definition: Stmt.h:1673
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
This represents &#39;#pragma omp teams distribute parallel for&#39; composite directive.
Definition: StmtOpenMP.h:3625
Expr * getImplicitObjectArgument() const
Retrieves the implicit object argument for the member call.
Definition: ExprCXX.cpp:505
Stmt * getHandlerBlock() const
Definition: StmtCXX.h:52
arg_iterator arg_begin()
Definition: ExprCXX.h:1376
llvm::APFloat getValue() const
Definition: Expr.h:1467
ObjCMethodDecl * getImplicitPropertySetter() const
Definition: ExprObjC.h:680
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
Definition: Expr.h:4673
param_iterator param_end()
Definition: Decl.h:3949
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:2769
const Expr * getSubExpr() const
Definition: Expr.h:3924
DeclarationNameInfo getNameInfo() const
Retrieve the name of the entity we&#39;re testing for, along with location information.
Definition: StmtCXX.h:277
Defines the C++ template declaration subclasses.
Opcode getOpcode() const
Definition: Expr.h:3148
StringRef P
CapturedStmt * getInnermostCapturedStmt()
Get innermost captured statement for the construct.
Definition: StmtOpenMP.h:226
Represents an attribute applied to a statement.
Definition: Stmt.h:905
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1737
static bool isImplicitThis(const Expr *E)
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies this name, if any.
Definition: StmtCXX.h:273
Expr * getLowerBound()
Get lower bound of array section.
Definition: ExprOpenMP.h:91
This represents &#39;#pragma omp target teams distribute&#39; combined directive.
Definition: StmtOpenMP.h:3762
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies this declaration.
Definition: ExprCXX.h:2945
Represents Objective-C&#39;s @throw statement.
Definition: StmtObjC.h:313
bool hasExplicitTemplateArgs() const
Determines whether this declaration reference was followed by an explicit template argument list...
Definition: Expr.h:1139
llvm::iterator_range< child_iterator > child_range
Definition: Stmt.h:460
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1262
ObjCSubscriptRefExpr - used for array and dictionary subscripting.
Definition: ExprObjC.h:803
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent...
Definition: ExprCXX.h:2456
bool getIsCXXTry() const
Definition: Stmt.h:2020
A container of type source information.
Definition: Decl.h:86
NestedNameSpecifier * getQualifier() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name...
Definition: ExprCXX.h:2285
static void printGroup(Decl **Begin, unsigned NumDecls, raw_ostream &Out, const PrintingPolicy &Policy, unsigned Indentation=0)
This represents &#39;#pragma omp parallel for&#39; directive.
Definition: StmtOpenMP.h:1518
MS property subscript expression.
Definition: ExprCXX.h:818
This represents &#39;#pragma omp target teams distribute parallel for&#39; combined directive.
Definition: StmtOpenMP.h:3830
Describes the capture of a variable or of this, or of a C++1y init-capture.
Definition: LambdaCapture.h:26
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:4077
MutableArrayRef< ParmVarDecl * >::iterator param_iterator
Definition: Decl.h:3944
void printExceptionSpecification(raw_ostream &OS, const PrintingPolicy &Policy) const
const Expr * getSubExpr() const
Definition: Expr.h:1537
Expr * getIndexExpr(unsigned Idx)
Definition: Expr.h:2070
This represents &#39;#pragma omp target exit data&#39; directive.
Definition: StmtOpenMP.h:2429
Stmt * getSubStmt()
Definition: Stmt.h:834
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC &#39;id&#39; type.
Definition: ExprObjC.h:1437
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:2722
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6683
unsigned getNumArgs() const
Determine the number of arguments to this type trait.
Definition: ExprCXX.h:2421
ObjCInterfaceDecl * getClassReceiver() const
Definition: ExprObjC.h:734
bool isArrow() const
Definition: ExprObjC.h:1465
Expr * getVal1() const
Definition: Expr.h:5277
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
Definition: ExprCXX.h:614
const char * getName() const
Definition: Stmt.cpp:342
unsigned getNumPlacementArgs() const
Definition: ExprCXX.h:1987
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
Defines the Objective-C statement AST node classes.
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:1006
Expr * getExprOperand() const
Definition: ExprCXX.h:716
Represents an expression – generally a full-expression – that introduces cleanups to be run at the ...
Definition: ExprCXX.h:3033
TypeSourceInfo * getArg(unsigned I) const
Retrieve the Ith argument.
Definition: ExprCXX.h:2424
Defines the clang::Expr interface and subclasses for C++ expressions.
StringRef getInputName(unsigned i) const
Definition: Stmt.h:1765
ObjCPropertyDecl * getExplicitProperty() const
Definition: ExprObjC.h:670
A C++ static_cast expression (C++ [expr.static.cast]).
Definition: ExprCXX.h:302
virtual ~PrinterHelper()
Expr * getExprOperand() const
Definition: ExprCXX.h:923
const Stmt * getSubStmt() const
Definition: StmtObjC.h:356
LabelStmt - Represents a label, which has a substatement.
Definition: Stmt.h:864
Expr * IgnoreImpCasts() LLVM_READONLY
IgnoreImpCasts - Skip past any implicit casts which might surround this expression.
Definition: Expr.h:2982
Represents a C99 designated initializer expression.
Definition: Expr.h:4234
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:297
One of these records is kept for each identifier that is lexed.
Stmt * getBody()
Definition: Stmt.h:1206
Expr * GetTemporaryExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue...
Definition: ExprCXX.h:4118
An element in an Objective-C dictionary literal.
Definition: ExprObjC.h:239
This represents &#39;#pragma omp parallel&#39; directive.
Definition: StmtOpenMP.h:276
ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.
Definition: Expr.h:3661
void print(raw_ostream &Out, unsigned Indentation=0, bool PrintInstantiation=false) const
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
Expr * getInit() const
Retrieve the initializer value.
Definition: Expr.h:4468
child_range children()
Definition: ExprObjC.h:227
Represents a member of a struct/union/class.
Definition: Decl.h:2571
Expr * getBase()
Retrieve the base object of this member expressions, e.g., the x in x.m.
Definition: ExprCXX.h:3548
Represents a place-holder for an object not to be initialized by anything.
Definition: Expr.h:4528
const DeclarationNameInfo & getNameInfo() const
Gets the full name info.
Definition: ExprCXX.h:2685
StringLiteral * getString()
Definition: ExprObjC.h:63
RetTy Visit(PTR(OMPClause) S)
CompoundStmt * getBody() const
Retrieve the body of the lambda.
Definition: ExprCXX.cpp:1029
unsigned getArrayExprIndex() const
For an array element node, returns the index into the array of expressions.
Definition: Expr.h:1961
const Expr * getRetValue() const
Definition: Stmt.cpp:937
bool hasExplicitTemplateArgs() const
Determines whether the member name was followed by an explicit template argument list.
Definition: Expr.h:2627
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
Definition: Expr.h:3872
QualType getDestroyedType() const
Retrieve the type being destroyed.
Definition: ExprCXX.cpp:246
Expr * getPlacementArg(unsigned i)
Definition: ExprCXX.h:1993
This represents &#39;#pragma omp target simd&#39; directive.
Definition: StmtOpenMP.h:3350
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
Definition: Expr.h:938
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3480
Defines some OpenMP-specific enums and functions.
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
Definition: Expr.h:4918
Expr * getSubExpr()
Definition: Expr.h:2860
This represents &#39;#pragma omp barrier&#39; directive.
Definition: StmtOpenMP.h:1849
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp, [NSNumber numberWithInt:42]];.
Definition: ExprObjC.h:171
Represents a reference to a non-type template parameter pack that has been substituted with a non-tem...
Definition: ExprCXX.h:3935
This represents &#39;#pragma omp critical&#39; directive.
Definition: StmtOpenMP.h:1444
LambdaCaptureDefault getCaptureDefault() const
Determine the default capture kind for this lambda.
Definition: ExprCXX.h:1682
OpenMPDirectiveKind getCancelRegion() const
Get cancellation region for the current cancellation point.
Definition: StmtOpenMP.h:2728
ArrayRef< TemplateArgumentLoc > template_arguments() const
Definition: ExprCXX.h:2742
bool hasExplicitTemplateArgs() const
Determines whether this lookup had explicit template arguments.
Definition: ExprCXX.h:2974
Selector getSelector() const
Definition: ExprObjC.h:442
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2246
bool isUnarySelector() const
Represents Objective-C&#39;s @catch statement.
Definition: StmtObjC.h:74
Expr * getLHS() const
Definition: ExprCXX.h:4212
StringRef getOpcodeStr() const
Definition: Expr.h:3167
IndirectGotoStmt - This represents an indirect goto.
Definition: Stmt.h:1339
Describes an C or C++ initializer list.
Definition: Expr.h:4000
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:659
This represents &#39;#pragma omp distribute parallel for&#39; composite directive.
Definition: StmtOpenMP.h:3065
Stmt * getBody() const override
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
Definition: Decl.cpp:4462
bool isArrow() const
Definition: ExprObjC.h:551
Expr * getKeyExpr() const
Definition: ExprObjC.h:851
This represents &#39;#pragma omp teams distribute parallel for simd&#39; composite directive.
Definition: StmtOpenMP.h:3554
Expr * getArraySize()
Definition: ExprCXX.h:1980
ForStmt - This represents a &#39;for (init;cond;inc)&#39; stmt.
Definition: Stmt.h:1234
Expr * getBaseExpr() const
Definition: ExprObjC.h:848
Expr * getOperand() const
Definition: ExprCXX.h:3660
const Expr * getThrowExpr() const
Definition: StmtObjC.h:325
< Capturing the *this object by copy
Definition: Lambda.h:37
bool isGlobalNew() const
Definition: ExprCXX.h:2005
Expr * getPtr() const
Definition: Expr.h:5267
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
Expr * getInitializer()
The initializer of this new-expression.
Definition: ExprCXX.h:2018
Stmt * getBody()
Definition: Stmt.h:1269
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3107
const Expr * getAssocExpr(unsigned i) const
Definition: Expr.h:4845
Stmt * getInit()
Definition: Stmt.h:1248
Expr * getOutputExpr(unsigned i)
Definition: Stmt.cpp:430
ArrayRef< TemplateArgumentLoc > template_arguments() const
Definition: Expr.h:2655
bool isClassReceiver() const
Definition: ExprObjC.h:740
const StringLiteral * getInputConstraintLiteral(unsigned i) const
Definition: Stmt.h:1774
static bool isPostfix(Opcode Op)
isPostfix - Return true if this is a postfix operation, like x++.
Definition: Expr.h:1833
CXXForRangeStmt - This represents C++0x [stmt.ranged]&#39;s ranged for statement, represented as &#39;for (ra...
Definition: StmtCXX.h:127
bool isArrow() const
Definition: Expr.h:2667
This represents &#39;#pragma omp cancellation point&#39; directive.
Definition: StmtOpenMP.h:2684
ObjCStringLiteral, used for Objective-C string literals i.e.
Definition: ExprObjC.h:51
Expr * getRHS() const
Definition: ExprCXX.h:4213
const CallExpr * getConfig() const
Definition: ExprCXX.h:216
bool isArrow() const
Definition: ExprCXX.h:802
New-expression has a C++98 paren-delimited initializer.
Definition: ExprCXX.h:1928
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
Definition: Expr.h:5364
Expr * getCond()
Definition: Stmt.h:1267
This represents &#39;#pragma omp teams&#39; directive.
Definition: StmtOpenMP.h:2627
NestedNameSpecifier * getQualifier() const
Fetches the nested-name qualifier, if one was given.
Definition: ExprCXX.h:2694
const Expr * getControllingExpr() const
Definition: Expr.h:4870
Helper class for OffsetOfExpr.
Definition: Expr.h:1903
Expr * getOperand() const
Definition: ExprCXX.h:4401
This represents &#39;#pragma omp teams distribute simd&#39; combined directive.
Definition: StmtOpenMP.h:3484
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1217
StringLiteral * getClobberStringLiteral(unsigned i)
Definition: Stmt.h:1808
StringRef getOutputName(unsigned i) const
Definition: Stmt.h:1737
ArrayTypeTrait
Names for the array type traits.
Definition: TypeTraits.h:91
Expr * Key
The key for the dictionary element.
Definition: ExprObjC.h:241
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1611
Represents a C++ member access expression where the actual member referenced could not be resolved be...
Definition: ExprCXX.h:3243
bool isCmpXChg() const
Definition: Expr.h:5311
bool isInitCapture(const LambdaCapture *Capture) const
Determine whether one of this lambda&#39;s captures is an init-capture.
Definition: ExprCXX.cpp:971
TypeSourceInfo * getTypeSourceInfo() const
Definition: ExprCXX.h:1852
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:1063
Stmt * getInit()
Definition: Stmt.h:992
bool isTypeOperand() const
Definition: ExprCXX.h:906
const IdentifierInfo * getUDSuffix() const
Returns the ud-suffix specified for this literal.
Definition: ExprCXX.cpp:748
Represents the this expression in C++.
Definition: ExprCXX.h:966
ObjCIvarDecl * getDecl()
Definition: ExprObjC.h:543
TypeTrait
Names for traits that operate specifically on types.
Definition: TypeTraits.h:21
bool isArrayForm() const
Definition: ExprCXX.h:2141
const ObjCAtCatchStmt * getCatchStmt(unsigned I) const
Retrieve a @catch statement.
Definition: StmtObjC.h:206
This represents &#39;#pragma omp target parallel for simd&#39; directive.
Definition: StmtOpenMP.h:3282
QualType getTypeAsWritten() const
getTypeAsWritten - Returns the type that this expression is casting to, as written in the source code...
Definition: Expr.h:3028
OpenMP 4.0 [2.4, Array Sections].
Definition: ExprOpenMP.h:45
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:3397
bool isStdInitListInitialization() const
Whether this constructor call was written as list-initialization, but was interpreted as forming a st...
Definition: ExprCXX.h:1347
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Definition: ExprCXX.h:2228
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:613
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1605
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3676
QualType getQueriedType() const
Definition: ExprCXX.h:2501
CompoundStmt * getSubStmt() const
Retrieve the compound statement that will be included in the program only if the existence of the sym...
Definition: StmtCXX.h:281
This represents &#39;#pragma omp taskgroup&#39; directive.
Definition: StmtOpenMP.h:1937
unsigned SuppressImplicitBase
When true, don&#39;t print the implicit &#39;self&#39; or &#39;this&#39; expressions.
NestedNameSpecifier * getQualifier() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name...
Definition: Expr.h:2597
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand...
Definition: Expr.h:2112
arg_iterator arg_end()
Definition: ExprCXX.h:1377
InitListExpr * getUpdater() const
Definition: Expr.h:4586
Represents a call to the builtin function __builtin_va_arg.
Definition: Expr.h:3906
void print(raw_ostream &OS, const PrintingPolicy &Policy) const
Print this nested name specifier to the given output stream.
void outputString(raw_ostream &OS) const
Definition: Expr.cpp:926
const DeclStmt * getConditionVariableDeclStmt() const
If this IfStmt has a condition variable, return the faux DeclStmt associated with the creation of tha...
Definition: Stmt.h:988
static StringRef getSourceText(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts, bool *Invalid=nullptr)
Returns a string for the source that the range encompasses.
Definition: Lexer.cpp:932
unsigned getValue() const
Definition: Expr.h:1434
This represents &#39;#pragma omp distribute&#39; directive.
Definition: StmtOpenMP.h:2938
This represents implicit clause &#39;depend&#39; for the &#39;#pragma omp task&#39; directive.
Expr * getSrcExpr() const
getSrcExpr - Return the Expr to be converted.
Definition: Expr.h:5051
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type...
Definition: ExprCXX.h:1833
Expr * getCond() const
Definition: Expr.h:3431
Pepresents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:3850
llvm::MutableArrayRef< Designator > designators()
Definition: Expr.h:4437
This represents one expression.
Definition: Expr.h:105
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:2686
IdentifierInfo * getFieldName() const
For a field or identifier offsetof node, returns the name of the field.
Definition: Expr.cpp:1426
bool isArrow() const
Determine whether this member expression used the &#39;->&#39; operator; otherwise, it used the &#39;...
Definition: ExprCXX.h:3565
int Id
Definition: ASTDiff.cpp:191
static void PrintFloatingLiteral(raw_ostream &OS, FloatingLiteral *Node, bool PrintSuffix)
bool isImplicitAccess() const
True if this is an implicit access, i.e., one in which the member being accessed was not written in t...
Definition: ExprCXX.cpp:1257
Represents a C++ functional cast expression that builds a temporary object.
Definition: ExprCXX.h:1561
const Stmt * getThen() const
Definition: Stmt.h:997
A C++ const_cast expression (C++ [expr.const.cast]).
Definition: ExprCXX.h:435
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:4979
VarDecl * getExceptionDecl() const
Definition: StmtCXX.h:50
IdentifierInfo * getDestroyedTypeIdentifier() const
In a dependent pseudo-destructor expression for which we do not have full type information on the des...
Definition: ExprCXX.h:2328
unsigned getNumInits() const
Definition: Expr.h:4030
bool isImplicitAccess() const
True if this is an implicit access, i.e.
Definition: ExprCXX.cpp:1204
Expr * getSubExpr() const
Get the initializer to use for each array element.
Definition: Expr.h:4640
Defines an enumeration for C++ overloaded operators.
const Expr * getCallee() const
Definition: Expr.h:2330
This represents &#39;#pragma omp target teams distribute parallel for simd&#39; combined directive.
Definition: StmtOpenMP.h:3914
QualType getArgumentType() const
Definition: Expr.h:2149
bool isArrow() const
Determine whether this pseudo-destructor expression was written using an &#39;->&#39; (otherwise, it used a &#39;.
Definition: ExprCXX.h:2291
Stmt * getBody()
Definition: Stmt.h:1161
Expr * getOrder() const
Definition: Expr.h:5270
StringRef getNameForSlot(unsigned argIndex) const
Retrieve the name at a given position in the selector.
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
Definition: ExprObjC.h:288
const CompoundStmt * getSynchBody() const
Definition: StmtObjC.h:282
Expr * getRHS()
Definition: Stmt.h:785
Represents Objective-C&#39;s @synchronized statement.
Definition: StmtObjC.h:262
ObjCSelectorExpr used for @selector in Objective-C.
Definition: ExprObjC.h:429
TypeSourceInfo * getTypeSourceInfo() const
Definition: Expr.h:2049
Represents an expression that computes the length of a parameter pack.
Definition: ExprCXX.h:3765
CXXTryStmt - A C++ try block, including all handlers.
Definition: StmtCXX.h:65
AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2] This AST node provides support ...
Definition: Expr.h:5028
IdentifierInfo & getAccessor() const
Definition: Expr.h:4940
This represents &#39;#pragma omp target teams distribute simd&#39; combined directive.
Definition: StmtOpenMP.h:3987
ArrayTypeTrait getTrait() const
Definition: ExprCXX.h:2499
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy)
Print a template argument list, including the &#39;<&#39; and &#39;>&#39; enclosing the template arguments.
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], or an enum decl which has a signed representation.
Definition: Type.cpp:1836
Kind getKind() const
Determine what kind of offsetof node this is.
Definition: Expr.h:1957
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
void print(llvm::raw_ostream &OS) const
Prints the full selector name (e.g. "foo:bar:").
QualType getType() const
Definition: Expr.h:127
virtual bool handledStmt(Stmt *E, raw_ostream &OS)=0
This represents &#39;#pragma omp for&#39; directive.
Definition: StmtOpenMP.h:1070
LabelDecl * getLabel() const
Definition: Stmt.h:1317
const Stmt * getTryBody() const
Retrieve the @try body.
Definition: StmtObjC.h:197
Represents a folding of a pack over an operator.
Definition: ExprCXX.h:4187
QualType getEncodedType() const
Definition: ExprObjC.h:407
ReturnStmt - This represents a return, optionally of an expression: return; return 4;...
Definition: Stmt.h:1444
This represents &#39;#pragma omp target teams&#39; directive.
Definition: StmtOpenMP.h:3703
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:904
This represents a Microsoft inline-assembly statement extension.
Definition: Stmt.h:1822
ObjCMethodDecl * getImplicitPropertyGetter() const
Definition: ExprObjC.h:675
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1789
CXXMethodDecl * getMethodDecl() const
Retrieves the declaration of the called method.
Definition: ExprCXX.cpp:517
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
Definition: ExprObjC.h:1188
AtomicOp getOp() const
Definition: Expr.h:5299
A member reference to an MSPropertyDecl.
Definition: ExprCXX.h:749
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:3879
const OffsetOfNode & getComponent(unsigned Idx) const
Definition: Expr.h:2056
unsigned getNumArgs() const
This represents &#39;#pragma omp cancel&#39; directive.
Definition: StmtOpenMP.h:2742
ValueDecl * getDecl()
Definition: Expr.h:1061
Selector getSelector() const
Definition: DeclObjC.h:321
const Expr * getSubExpr() const
Definition: Expr.h:1753
const Expr * getSubExpr() const
Definition: ExprCXX.h:1240
CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr.cast]), which uses the syntax (Type)expr.
Definition: Expr.h:3039
CXXMethodDecl * getCallOperator() const
Retrieve the function call operator associated with this lambda expression.
Definition: ExprCXX.cpp:1018
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:707
Expr * getLHS()
An array access can be written A[4] or 4[A] (both are equivalent).
Definition: Expr.h:2235
bool getValue() const
Definition: ExprCXX.h:563
This file defines OpenMP AST classes for clauses.
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1...
Definition: Expr.h:1525
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: ExprObjC.h:1342
This represents &#39;#pragma omp flush&#39; directive.
Definition: StmtOpenMP.h:2010
bool hasClausesOfKind() const
Returns true if the current directive has one or more clauses of a specific kind. ...
Definition: StmtOpenMP.h:162
This represents &#39;#pragma omp parallel for simd&#39; directive.
Definition: StmtOpenMP.h:1598
DoStmt - This represents a &#39;do/while&#39; stmt.
Definition: Stmt.h:1185
StringRef getBridgeKindName() const
Retrieve the kind of bridge being performed as a string.
Definition: ExprObjC.cpp:355
param_iterator param_begin()
Definition: Decl.h:3948
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the member name.
Definition: ExprCXX.h:3344
const DeclarationNameInfo & getNameInfo() const
Retrieve the name that this expression refers to.
Definition: ExprCXX.h:2929
Expr * getArgument()
Definition: ExprCXX.h:2154
LiteralOperatorKind getLiteralOperatorKind() const
Returns the kind of literal operator invocation which this expression represents. ...
Definition: ExprCXX.cpp:719
This represents &#39;#pragma omp target enter data&#39; directive.
Definition: StmtOpenMP.h:2370
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Definition: ExprCXX.h:343
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:879
Expr * getBase() const
Definition: Expr.h:4583
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
Definition: Expr.h:3729
unsigned getNumArgs() const
Return the number of actual arguments in this message, not counting the receiver. ...
Definition: ExprObjC.h:1329
Kind
This captures a statement into a function.
Definition: Stmt.h:2077
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition: ExprCXX.h:1423
operator "" X (const CharT *, size_t)
Definition: ExprCXX.h:509
ExpressionTrait getTrait() const
Definition: ExprCXX.h:2563
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:5101
bool isImplicitProperty() const
Definition: ExprObjC.h:667
IdentifierInfo * getIdentifierInfoForSlot(unsigned argIndex) const
Retrieve the identifier at a given position in the selector.
Raw form: operator "" X<cs...> ()
Definition: ExprCXX.h:500
unsigned getNumExprs() const
Definition: Expr.h:4746
This represents &#39;#pragma omp single&#39; directive.
Definition: StmtOpenMP.h:1342
unsigned Indentation
The number of spaces to use to indent each line.
Definition: PrettyPrinter.h:68
body_range body()
Definition: Stmt.h:644
capture_iterator explicit_capture_begin() const
Retrieve an iterator pointing to the first explicit lambda capture.
Definition: ExprCXX.cpp:988
Defines enumerations for expression traits intrinsics.
unsigned ConstantsAsWritten
Whether we should print the constant expressions as written in the sources.
unsigned UnderscoreAlignof
Whether we can use &#39;_Alignof&#39; rather than &#39;__alignof&#39;.
const Stmt * getCatchBody() const
Definition: StmtObjC.h:90
unsigned getNumHandlers() const
Definition: StmtCXX.h:103
Expr * getSubExpr() const
Definition: Expr.h:1816
bool hasExplicitTemplateArgs() const
Determines whether this member expression actually had a C++ template argument list explicitly specif...
Definition: ExprCXX.h:3407
This is a basic class for representing single OpenMP executable directive.
Definition: StmtOpenMP.h:33
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"...
Definition: ExprCXX.h:1873
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c dictionary literal.
Definition: ExprObjC.h:342
Expr * getLHS()
Definition: Stmt.h:784
static const char * getExpressionTraitName(ExpressionTrait ET)
A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit...
Definition: ExprCXX.h:477
DeclarationName getName() const
getName - Returns the embedded declaration name.
ArrayRef< const Attr * > getAttrs() const
Definition: Stmt.h:939
Represents a call to a member function that may be written either with member call syntax (e...
Definition: ExprCXX.h:164
Defines several types used to describe C++ lambda expressions that are shared between the parser and ...
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
Definition: Stmt.h:505
const Expr * getExpr(unsigned Init) const
Definition: Expr.h:4748
DeclarationNameInfo getDirectiveName() const
Return name of the directive.
Definition: StmtOpenMP.h:1502
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2041
std::string getValueAsString(unsigned Radix) const
Definition: Expr.cpp:782
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:186
SourceLocation getColonLoc() const
Definition: ExprOpenMP.h:109
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
This represents &#39;#pragma omp taskwait&#39; directive.
Definition: StmtOpenMP.h:1893
QualType getAllocatedType() const
Definition: ExprCXX.h:1947
This file defines OpenMP nodes for declarative directives.
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load, __atomic_store, and __atomic_compare_exchange_*, for the similarly-named C++11 instructions, and __c11 variants for <stdatomic.h>, and corresponding __opencl_atomic_* for OpenCL 2.0.
Definition: Expr.h:5235
UnaryExprOrTypeTrait getKind() const
Definition: Expr.h:2143
ObjCProtocolExpr used for protocol expression in Objective-C.
Definition: ExprObjC.h:474
const StringLiteral * getOutputConstraintLiteral(unsigned i) const
Definition: Stmt.h:1746
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:2929
Stmt * getCapturedStmt()
Retrieve the statement being captured.
Definition: Stmt.h:2178
bool hasTemplateKeyword() const
Determines whether the member name was preceded by the template keyword.
Definition: ExprCXX.h:3403
CharacterKind getKind() const
Definition: Expr.h:1427
This represents &#39;#pragma omp target&#39; directive.
Definition: StmtOpenMP.h:2254
Expr * getInputExpr(unsigned i)
Definition: Stmt.cpp:441
static const char * getTypeTraitName(TypeTrait TT)
void dumpPretty(const ASTContext &Context) const
dumpPretty/printPretty - These two methods do a "pretty print" of the AST back to its original source...
bool isParenTypeId() const
Definition: ExprCXX.h:2002
IdentType getIdentType() const
Definition: Expr.h:1236
void printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const
Expr * getArrayRangeStart(const Designator &D) const
Definition: Expr.cpp:3895
Expr * getSubExpr()
Definition: ExprObjC.h:135
An expression trait intrinsic.
Definition: ExprCXX.h:2526
This represents &#39;#pragma omp ordered&#39; directive.
Definition: StmtOpenMP.h:2065
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition: Expr.h:3616
This represents &#39;#pragma omp target update&#39; directive.
Definition: StmtOpenMP.h:3006
ObjCBoxedExpr - used for generalized expression boxing.
Definition: ExprObjC.h:117
bool isArgumentType() const
Definition: Expr.h:2148
ArrayRef< TemplateArgumentLoc > template_arguments() const
Definition: ExprCXX.h:3435
LLVM_READONLY bool isPrintable(unsigned char c)
Return true if this character is an ASCII printable character; that is, a character that should take ...
Definition: CharInfo.h:140
const DeclStmt * getConditionVariableDeclStmt() const
If this WhileStmt has a condition variable, return the faux DeclStmt associated with the creation of ...
Definition: Stmt.h:1154
Representation of a Microsoft __if_exists or __if_not_exists statement with a dependent name...
Definition: StmtCXX.h:241
void printName(raw_ostream &OS) const
printName - Print the human-readable name to a stream.
bool hasTemplateKeyword() const
Determines whether the name in this declaration reference was preceded by the template keyword...
Definition: Expr.h:1135
A qualified reference to a name whose declaration cannot yet be resolved.
Definition: ExprCXX.h:2887
Expr * Value
The value of the dictionary element.
Definition: ExprObjC.h:244
const Expr * getInitializer() const
Definition: Expr.h:2748
InitializationStyle getInitializationStyle() const
The kind of initializer this new-expression has.
Definition: ExprCXX.h:2011
Expr * getLHS() const
Definition: Expr.h:3151
ArrayRef< TemplateArgument > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
Definition: TemplateBase.h:354
CompoundAssignOperator - For compound assignments (e.g.
Definition: Expr.h:3319
Represents a C11 generic selection.
Definition: Expr.h:4812
StringRef getName() const
Return the actual identifier string.
const Expr * getBase() const
Definition: Expr.h:4936
Expr * getInstanceReceiver()
Returns the object expression (receiver) for an instance message, or null for a message that is not a...
Definition: ExprObjC.h:1207
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition: Expr.h:3572
An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers...
Definition: ExprObjC.h:1575
ast_type_traits::DynTypedNode Node
Represents a reference to a function parameter pack that has been substituted but not yet expanded...
Definition: ExprCXX.h:3999
Represents a template argument.
Definition: TemplateBase.h:51
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression which will be evaluated if the condnition evaluates to false;...
Definition: Expr.h:3529
NullStmt - This is the null statement ";": C99 6.8.3p3.
Definition: Stmt.h:574
bool isMutable() const
Determine whether the lambda is mutable, meaning that any captures values can be modified.
Definition: ExprCXX.cpp:1040
bool isTypeOperand() const
Definition: ExprCXX.h:699
unsigned getNumAssocs() const
Definition: Expr.h:4839
Dataflow Directional Tag Classes.
static std::string getPropertyNameFromSetterSelector(Selector Sel)
Return the property name for the given setter selector.
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
bool isValid() const
Return true if this is a valid SourceLocation object.
bool isVolatile() const
Definition: Stmt.h:1528
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1208
DeclarationNameInfo getMemberNameInfo() const
Retrieve the member declaration name info.
Definition: Expr.h:2660
Represents a delete expression for memory deallocation and destructor calls, e.g. ...
Definition: ExprCXX.h:2100
OverloadedOperatorKind getOperator() const
Returns the kind of overloaded operator that this expression refers to.
Definition: ExprCXX.h:106
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:22
NonTypeTemplateParmDecl * getParameterPack() const
Retrieve the non-type template parameter pack being substituted.
Definition: ExprCXX.h:3963
MSPropertyDecl * getPropertyDecl() const
Definition: ExprCXX.h:801
Parameter for Objective-C &#39;self&#39; argument.
Definition: Decl.h:1496
This represents &#39;#pragma omp section&#39; directive.
Definition: StmtOpenMP.h:1280
This represents &#39;#pragma omp teams distribute&#39; directive.
Definition: StmtOpenMP.h:3416
QualType getAssocType(unsigned i) const
Definition: Expr.h:4863
A runtime availability query.
Definition: ExprObjC.h:1641
A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]).
Definition: ExprCXX.h:390
This represents &#39;#pragma omp simd&#39; directive.
Definition: StmtOpenMP.h:1005
Represents a &#39;co_yield&#39; expression.
Definition: ExprCXX.h:4423
Expr * getOperand() const
Retrieve the operand of the &#39;co_return&#39; statement.
Definition: StmtCXX.h:459
Represents a C++11 pack expansion that produces a sequence of expressions.
Definition: ExprCXX.h:3693
bool isListInitialization() const
Whether this constructor call was written as list-initialization.
Definition: ExprCXX.h:1340
SEHExceptStmt * getExceptHandler() const
Returns 0 if not defined.
Definition: Stmt.cpp:957
const Expr * getSynchExpr() const
Definition: StmtObjC.h:290
bool isIfExists() const
Determine whether this is an __if_exists statement.
Definition: StmtCXX.h:266
NestedNameSpecifierLoc getQualifierLoc() const
Definition: ExprCXX.h:804
const DeclarationNameInfo & getMemberNameInfo() const
Retrieve the full name info for the member that this expression refers to.
Definition: ExprCXX.h:3575
This represents &#39;#pragma omp atomic&#39; directive.
Definition: StmtOpenMP.h:2120
TypeSourceInfo * getTypeOperandSourceInfo() const
Retrieve source information for the type operand.
Definition: ExprCXX.h:706
Expr * getArrayRangeEnd(const Designator &D) const
Definition: Expr.cpp:3901
const Stmt * getBody() const
Definition: Stmt.h:1076
llvm::APInt getValue() const
Definition: Expr.h:1300
Represents a __leave statement.
Definition: Stmt.h:2042
LabelDecl * getLabel() const
Definition: Expr.h:3594
QualType getClassReceiver() const
Returns the type of a class message send, or NULL if the message is not a class message.
Definition: ExprObjC.h:1226
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
Definition: ExprCXX.h:3641
SwitchStmt - This represents a &#39;switch&#39; stmt.
Definition: Stmt.h:1037
Capturing variable-length array type.
Definition: Lambda.h:39
Expr * getOrderFail() const
Definition: Expr.h:5283
DeclarationNameInfo getNameInfo() const
Definition: Expr.h:1065
Represents the body of a coroutine.
Definition: StmtCXX.h:302
bool hasTemplateKeyword() const
Determines whether the name was preceded by the template keyword.
Definition: ExprCXX.h:2724
Expr * getBase() const
Definition: ExprObjC.h:1463
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2202
This file defines OpenMP AST classes for executable directives and clauses.
bool hasBraces() const
Definition: Stmt.h:1850
Represents Objective-C&#39;s collection statement.
Definition: StmtObjC.h:24
static StringRef getIdentTypeName(IdentType IT)
Definition: Expr.cpp:473
ObjCEncodeExpr, used for @encode in Objective-C.
Definition: ExprObjC.h:386
An implicit indirection through a C++ base class, when the field found is in a base class...
Definition: Expr.h:1915
Represents a call to a CUDA kernel function.
Definition: ExprCXX.h:203
Represents a &#39;co_await&#39; expression.
Definition: ExprCXX.h:4340
Stmt * getInit()
Definition: Stmt.h:1072
Opcode getOpcode() const
Definition: Expr.h:1813
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1388
decl_range decls()
Definition: Stmt.h:550
Represents Objective-C&#39;s @finally statement.
Definition: StmtObjC.h:120
StringRef getAsmString() const
Definition: Stmt.h:1856
unsigned Alignof
Whether we can use &#39;alignof&#39; rather than &#39;__alignof&#39;.
bool hasAssociatedStmt() const
Returns true if directive has associated statement.
Definition: StmtOpenMP.h:193
const Expr * getBase() const
Definition: ExprObjC.h:547
bool isArrow() const
Determine whether this member expression used the &#39;->&#39; operator; otherwise, it used the &#39;...
Definition: ExprCXX.h:3337
Capturing the *this object by reference.
Definition: Lambda.h:35
const char * getOpenMPDirectiveName(OpenMPDirectiveKind Kind)
Definition: OpenMPKinds.cpp:31
unsigned getNumClobbers() const
Definition: Stmt.h:1573
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:513
SourceManager & getSourceManager()
Definition: ASTContext.h:671
Expr * getRHS() const
Definition: Expr.h:3841
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
Definition: ExprCXX.h:3122
SEHFinallyStmt * getFinallyHandler() const
Definition: Stmt.cpp:961
GotoStmt - This represents a direct goto.
Definition: Stmt.h:1305
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1134
Expr * getTarget()
Definition: Stmt.h:1359
A template argument list.
Definition: DeclTemplate.h:210
Expr * getSrcExpr() const
getSrcExpr - Return the Expr to be converted.
Definition: Expr.h:3753
ArrayRef< TemplateArgumentLoc > template_arguments() const
Definition: Expr.h:1167
CapturedDecl * getCapturedDecl()
Retrieve the outlined function declaration.
Definition: Stmt.cpp:1109
Expr * getCond()
Definition: Stmt.h:1203
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\, const ASTContext *Context=nullptr) const
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2472
Defines the clang::SourceLocation class and associated facilities.
This represents &#39;#pragma omp target parallel&#39; directive.
Definition: StmtOpenMP.h:2487
ContinueStmt - This represents a continue.
Definition: Stmt.h:1382
Represents a loop initializing the elements of an array.
Definition: Expr.h:4618
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:3792
Expr * getFilterExpr() const
Definition: Stmt.h:1945
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition: Expr.h:3470
CXXCatchStmt - This represents a C++ catch block.
Definition: StmtCXX.h:29
VarDecl * getLoopVariable()
Definition: StmtCXX.cpp:77
An index into an array.
Definition: Expr.h:1908
Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr.type.conv]).
Definition: ExprCXX.h:1494
bool isPackExpansion() const
Determines whether this dictionary element is a pack expansion.
Definition: ExprObjC.h:254
Expr * getOperand() const
Definition: ExprCXX.h:4361
Expr * getRHS() const
Definition: Expr.h:3443
WhileStmt - This represents a &#39;while&#39; stmt.
Definition: Stmt.h:1129
Capturing by reference.
Definition: Lambda.h:38
SourceLocation getLParenLoc() const
Definition: ExprCXX.h:1530
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2390
CompoundStmt * getTryBlock()
Definition: StmtCXX.h:96
The receiver is a class.
Definition: ExprObjC.h:1052
Represents Objective-C&#39;s @try ... @catch ... @finally statement.
Definition: StmtObjC.h:154
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:268
bool isGlobalDelete() const
Definition: ExprCXX.h:2140
This represents &#39;#pragma omp taskloop simd&#39; directive.
Definition: StmtOpenMP.h:2872
unsigned getNumCatchStmts() const
Retrieve the number of @catch statements in this try-catch-finally block.
Definition: StmtObjC.h:203
Expr * getBase() const
Retrieve the base object of this member expressions, e.g., the x in x.m.
Definition: ExprCXX.h:3328
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1573
bool hasExplicitParameters() const
Determine whether this lambda has an explicit parameter list vs.
Definition: ExprCXX.h:1810
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2290
Expr * getPattern()
Retrieve the pattern of the pack expansion.
Definition: ExprCXX.h:3722
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:275
Expr * getLHS() const
Definition: Expr.h:3839
Stmt * getBody() const
Retrieve the body of the coroutine as written.
Definition: StmtCXX.h:363
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:954
Abstract class common to all of the C++ "named"/"keyword" casts.
Definition: ExprCXX.h:246
This represents &#39;#pragma omp sections&#39; directive.
Definition: StmtOpenMP.h:1212
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
Definition: ExprObjC.h:82
bool isObjectReceiver() const
Definition: ExprObjC.h:738
unsigned getNumComponents() const
Definition: Expr.h:2066
This represents &#39;#pragma omp target data&#39; directive.
Definition: StmtOpenMP.h:2312
OpenMPDirectiveKind getCancelRegion() const
Get cancellation region for the current cancellation point.
Definition: StmtOpenMP.h:2791
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:976
static bool printExprAsWritten(raw_ostream &OS, Expr *E, const ASTContext *Context)
Prints the given expression using the original source text.
Expr * getRHS() const
Definition: Expr.h:3153
unsigned IncludeNewlines
When true, include newlines after statements like "break", etc.
BreakStmt - This represents a break.
Definition: Stmt.h:1408
const VarDecl * getCatchParamDecl() const
Definition: StmtObjC.h:94
static bool isImplicitSelf(const Expr *E)
const char * getCastName() const
getCastName - Get the name of the C++ cast being used, e.g., "static_cast", "dynamic_cast", "reinterpret_cast", or "const_cast".
Definition: ExprCXX.cpp:543
Expr * getOperand() const
Definition: ExprCXX.h:4436
Stmt * getSubStmt()
Definition: Stmt.h:884
QualType getTypeAsWritten() const
Retrieve the type that is being constructed, as specified in the source code.
Definition: ExprCXX.h:3160
QualType getType() const
Definition: Decl.h:647
ParmVarDecl * getParameterPack() const
Get the parameter pack which this expression refers to.
Definition: ExprCXX.h:4028
unsigned getNumArgs() const
Definition: ExprCXX.h:1385
const Expr * getBase() const
Definition: ExprObjC.h:719
const Expr * getCond() const
Definition: Stmt.h:995
static StringRef getOpcodeStr(Opcode Op)
getOpcodeStr - Turn an Opcode enum value into the punctuation char it corresponds to...
Definition: Expr.cpp:1151
This represents &#39;#pragma omp taskyield&#39; directive.
Definition: StmtOpenMP.h:1805
This represents &#39;#pragma omp distribute parallel for simd&#39; composite directive.
Definition: StmtOpenMP.h:3145
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition: ExprCXX.h:550
NestedNameSpecifier * getQualifier() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name.
Definition: Expr.h:1088
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type, member-designator).
Definition: Expr.h:2007
Expr * getQueriedExpression() const
Definition: ExprCXX.h:2565
This represents &#39;#pragma omp parallel sections&#39; directive.
Definition: StmtOpenMP.h:1666
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Definition: ExprCXX.h:877
Expr * getCommon() const
getCommon - Return the common expression, written to the left of the condition.
Definition: Expr.h:3510
const Expr * getCond() const
Definition: Stmt.h:1075
The receiver is a superclass.
Definition: ExprObjC.h:1058
BinaryOperatorKind getOperator() const
Definition: ExprCXX.h:4230
const LangOptions & getLangOpts() const
Definition: ASTContext.h:716
NamedDecl * getPack() const
Retrieve the parameter pack.
Definition: ExprCXX.h:3836
Represents Objective-C&#39;s @autoreleasepool Statement.
Definition: StmtObjC.h:345
CompoundStmt * getTryBlock() const
Definition: Stmt.h:2022
Stmt * getSubStmt()
Definition: Stmt.h:943
InitListExpr * getSyntacticForm() const
Definition: Expr.h:4157
Expr * getBaseExpr() const
Definition: ExprCXX.h:800
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:4708
CompoundStmt * getBlock() const
Definition: Stmt.h:1949
Expr * getWeak() const
Definition: Expr.h:5293
This represents &#39;#pragma omp target parallel for&#39; directive.
Definition: StmtOpenMP.h:2547
Attr - This represents one attribute.
Definition: Attr.h:43
operator "" X (unsigned long long)
Definition: ExprCXX.h:503
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:97
TypeTrait getTrait() const
Determine which type trait this expression uses.
Definition: ExprCXX.h:2411
Expr * getLength()
Get length of array section.
Definition: ExprOpenMP.h:99
const DeclarationNameInfo & getMemberNameInfo() const
Retrieve the name of the member that this expression refers to.
Definition: ExprCXX.h:3369
Expr * getCookedLiteral()
If this is not a raw user-defined literal, get the underlying cooked literal (representing the litera...
Definition: ExprCXX.cpp:740
Expr * getBase()
An array section can be written only as Base[LowerBound:Length].
Definition: ExprOpenMP.h:82
Stmt * getSubStmt()
Definition: Stmt.h:786
const DeclStmt * getConditionVariableDeclStmt() const
If this SwitchStmt has a condition variable, return the faux DeclStmt associated with the creation of...
Definition: Stmt.h:1068
This represents &#39;#pragma omp taskloop&#39; directive.
Definition: StmtOpenMP.h:2807