Lines Matching defs:Node
155 void VisitStmt(Stmt *Node) LLVM_ATTRIBUTE_UNUSED {
159 void VisitExpr(Expr *Node) LLVM_ATTRIBUTE_UNUSED {
163 void VisitCXXNamedCastExpr(CXXNamedCastExpr *Node);
167 void Visit##CLASS(CLASS *Node);
179 void StmtPrinter::PrintRawCompoundStmt(CompoundStmt *Node) {
180 assert(Node && "Compound statement cannot be null");
182 PrintFPPragmas(Node);
183 for (auto *I : Node->body())
258 void StmtPrinter::VisitNullStmt(NullStmt *Node) {
262 void StmtPrinter::VisitDeclStmt(DeclStmt *Node) {
264 PrintRawDeclStmt(Node);
268 void StmtPrinter::VisitCompoundStmt(CompoundStmt *Node) {
270 PrintRawCompoundStmt(Node);
274 void StmtPrinter::VisitCaseStmt(CaseStmt *Node) {
276 PrintExpr(Node->getLHS());
277 if (Node->getRHS()) {
279 PrintExpr(Node->getRHS());
283 PrintStmt(Node->getSubStmt(), 0);
286 void StmtPrinter::VisitDefaultStmt(DefaultStmt *Node) {
288 PrintStmt(Node->getSubStmt(), 0);
291 void StmtPrinter::VisitLabelStmt(LabelStmt *Node) {
292 Indent(-1) << Node->getName() << ":" << NL;
293 PrintStmt(Node->getSubStmt(), 0);
296 void StmtPrinter::VisitAttributedStmt(AttributedStmt *Node) {
297 llvm::ArrayRef<const Attr *> Attrs = Node->getAttrs();
304 PrintStmt(Node->getSubStmt(), 0);
365 void StmtPrinter::VisitSwitchStmt(SwitchStmt *Node) {
367 if (Node->getInit())
368 PrintInitStmt(Node->getInit(), 8);
369 if (const DeclStmt *DS = Node->getConditionVariableDeclStmt())
372 PrintExpr(Node->getCond());
374 PrintControlledStmt(Node->getBody());
377 void StmtPrinter::VisitWhileStmt(WhileStmt *Node) {
379 if (const DeclStmt *DS = Node->getConditionVariableDeclStmt())
382 PrintExpr(Node->getCond());
384 PrintStmt(Node->getBody());
387 void StmtPrinter::VisitDoStmt(DoStmt *Node) {
389 if (auto *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
394 PrintStmt(Node->getBody());
399 PrintExpr(Node->getCond());
403 void StmtPrinter::VisitForStmt(ForStmt *Node) {
405 if (Node->getInit())
406 PrintInitStmt(Node->getInit(), 5);
408 OS << (Node->getCond() ? "; " : ";");
409 if (const DeclStmt *DS = Node->getConditionVariableDeclStmt())
411 else if (Node->getCond())
412 PrintExpr(Node->getCond());
414 if (Node->getInc()) {
416 PrintExpr(Node->getInc());
419 PrintControlledStmt(Node->getBody());
422 void StmtPrinter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *Node) {
424 if (auto *DS = dyn_cast<DeclStmt>(Node->getElement()))
427 PrintExpr(cast<Expr>(Node->getElement()));
429 PrintExpr(Node->getCollection());
431 PrintControlledStmt(Node->getBody());
434 void StmtPrinter::VisitCXXForRangeStmt(CXXForRangeStmt *Node) {
436 if (Node->getInit())
437 PrintInitStmt(Node->getInit(), 5);
440 Node->getLoopVariable()->print(OS, SubPolicy, IndentLevel);
442 PrintExpr(Node->getRangeInit());
444 PrintControlledStmt(Node->getBody());
447 void StmtPrinter::VisitMSDependentExistsStmt(MSDependentExistsStmt *Node) {
449 if (Node->isIfExists())
455 = Node->getQualifierLoc().getNestedNameSpecifier())
458 OS << Node->getNameInfo() << ") ";
460 PrintRawCompoundStmt(Node->getSubStmt());
463 void StmtPrinter::VisitGotoStmt(GotoStmt *Node) {
464 Indent() << "goto " << Node->getLabel()->getName() << ";";
468 void StmtPrinter::VisitIndirectGotoStmt(IndirectGotoStmt *Node) {
470 PrintExpr(Node->getTarget());
475 void StmtPrinter::VisitContinueStmt(ContinueStmt *Node) {
480 void StmtPrinter::VisitBreakStmt(BreakStmt *Node) {
485 void StmtPrinter::VisitReturnStmt(ReturnStmt *Node) {
487 if (Node->getRetValue()) {
489 PrintExpr(Node->getRetValue());
495 void StmtPrinter::VisitGCCAsmStmt(GCCAsmStmt *Node) {
498 if (Node->isVolatile())
501 if (Node->isAsmGoto())
505 VisitStringLiteral(Node->getAsmString());
508 if (Node->getNumOutputs() != 0 || Node->getNumInputs() != 0 ||
509 Node->getNumClobbers() != 0 || Node->getNumLabels() != 0)
512 for (unsigned i = 0, e = Node->getNumOutputs(); i != e; ++i) {
516 if (!Node->getOutputName(i).empty()) {
518 OS << Node->getOutputName(i);
522 VisitStringLiteral(Node->getOutputConstraintLiteral(i));
524 Visit(Node->getOutputExpr(i));
529 if (Node->getNumInputs() != 0 || Node->getNumClobbers() != 0 ||
530 Node->getNumLabels() != 0)
533 for (unsigned i = 0, e = Node->getNumInputs(); i != e; ++i) {
537 if (!Node->getInputName(i).empty()) {
539 OS << Node->getInputName(i);
543 VisitStringLiteral(Node->getInputConstraintLiteral(i));
545 Visit(Node->getInputExpr(i));
550 if (Node->getNumClobbers() != 0 || Node->getNumLabels())
553 for (unsigned i = 0, e = Node->getNumClobbers(); i != e; ++i) {
557 VisitStringLiteral(Node->getClobberStringLiteral(i));
561 if (Node->getNumLabels() != 0)
564 for (unsigned i = 0, e = Node->getNumLabels(); i != e; ++i) {
567 OS << Node->getLabelName(i);
574 void StmtPrinter::VisitMSAsmStmt(MSAsmStmt *Node) {
577 if (Node->hasBraces())
579 OS << Node->getAsmString() << NL;
580 if (Node->hasBraces())
584 void StmtPrinter::VisitCapturedStmt(CapturedStmt *Node) {
585 PrintStmt(Node->getCapturedDecl()->getBody());
588 void StmtPrinter::VisitSYCLKernelCallStmt(SYCLKernelCallStmt *Node) {
589 PrintStmt(Node->getOutlinedFunctionDecl()->getBody());
592 void StmtPrinter::VisitObjCAtTryStmt(ObjCAtTryStmt *Node) {
594 if (auto *TS = dyn_cast<CompoundStmt>(Node->getTryBody())) {
599 for (ObjCAtCatchStmt *catchStmt : Node->catch_stmts()) {
610 if (auto *FS = static_cast<ObjCAtFinallyStmt *>(Node->getFinallyStmt())) {
619 void StmtPrinter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *Node) {
622 void StmtPrinter::VisitObjCAtCatchStmt (ObjCAtCatchStmt *Node) {
626 void StmtPrinter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *Node) {
628 if (Node->getThrowExpr()) {
630 PrintExpr(Node->getThrowExpr());
636 ObjCAvailabilityCheckExpr *Node) {
640 void StmtPrinter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *Node) {
642 PrintExpr(Node->getSynchExpr());
644 PrintRawCompoundStmt(Node->getSynchBody());
648 void StmtPrinter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *Node) {
650 PrintRawCompoundStmt(cast<CompoundStmt>(Node->getSubStmt()));
654 void StmtPrinter::PrintRawCXXCatchStmt(CXXCatchStmt *Node) {
656 if (Decl *ExDecl = Node->getExceptionDecl())
661 PrintRawCompoundStmt(cast<CompoundStmt>(Node->getHandlerBlock()));
664 void StmtPrinter::VisitCXXCatchStmt(CXXCatchStmt *Node) {
666 PrintRawCXXCatchStmt(Node);
670 void StmtPrinter::VisitCXXTryStmt(CXXTryStmt *Node) {
672 PrintRawCompoundStmt(Node->getTryBlock());
673 for (unsigned i = 0, e = Node->getNumHandlers(); i < e; ++i) {
675 PrintRawCXXCatchStmt(Node->getHandler(i));
680 void StmtPrinter::VisitSEHTryStmt(SEHTryStmt *Node) {
681 Indent() << (Node->getIsCXXTry() ? "try " : "__try ");
682 PrintRawCompoundStmt(Node->getTryBlock());
683 SEHExceptStmt *E = Node->getExceptHandler();
684 SEHFinallyStmt *F = Node->getFinallyHandler();
694 void StmtPrinter::PrintRawSEHFinallyStmt(SEHFinallyStmt *Node) {
696 PrintRawCompoundStmt(Node->getBlock());
700 void StmtPrinter::PrintRawSEHExceptHandler(SEHExceptStmt *Node) {
702 VisitExpr(Node->getFilterExpr());
704 PrintRawCompoundStmt(Node->getBlock());
708 void StmtPrinter::VisitSEHExceptStmt(SEHExceptStmt *Node) {
710 PrintRawSEHExceptHandler(Node);
714 void StmtPrinter::VisitSEHFinallyStmt(SEHFinallyStmt *Node) {
716 PrintRawSEHFinallyStmt(Node);
720 void StmtPrinter::VisitSEHLeaveStmt(SEHLeaveStmt *Node) {
729 void StmtPrinter::VisitOMPCanonicalLoop(OMPCanonicalLoop *Node) {
730 PrintStmt(Node->getLoopStmt());
747 void StmtPrinter::VisitOMPMetaDirective(OMPMetaDirective *Node) {
749 PrintOMPExecutableDirective(Node);
752 void StmtPrinter::VisitOMPParallelDirective(OMPParallelDirective *Node) {
754 PrintOMPExecutableDirective(Node);
757 void StmtPrinter::VisitOMPSimdDirective(OMPSimdDirective *Node) {
759 PrintOMPExecutableDirective(Node);
762 void StmtPrinter::VisitOMPTileDirective(OMPTileDirective *Node) {
764 PrintOMPExecutableDirective(Node);
767 void StmtPrinter::VisitOMPUnrollDirective(OMPUnrollDirective *Node) {
769 PrintOMPExecutableDirective(Node);
772 void StmtPrinter::VisitOMPReverseDirective(OMPReverseDirective *Node) {
774 PrintOMPExecutableDirective(Node);
777 void StmtPrinter::VisitOMPInterchangeDirective(OMPInterchangeDirective *Node) {
779 PrintOMPExecutableDirective(Node);
782 void StmtPrinter::VisitOMPForDirective(OMPForDirective *Node) {
784 PrintOMPExecutableDirective(Node);
787 void StmtPrinter::VisitOMPForSimdDirective(OMPForSimdDirective *Node) {
789 PrintOMPExecutableDirective(Node);
792 void StmtPrinter::VisitOMPSectionsDirective(OMPSectionsDirective *Node) {
794 PrintOMPExecutableDirective(Node);
797 void StmtPrinter::VisitOMPSectionDirective(OMPSectionDirective *Node) {
799 PrintOMPExecutableDirective(Node);
802 void StmtPrinter::VisitOMPScopeDirective(OMPScopeDirective *Node) {
804 PrintOMPExecutableDirective(Node);
807 void StmtPrinter::VisitOMPSingleDirective(OMPSingleDirective *Node) {
809 PrintOMPExecutableDirective(Node);
812 void StmtPrinter::VisitOMPMasterDirective(OMPMasterDirective *Node) {
814 PrintOMPExecutableDirective(Node);
817 void StmtPrinter::VisitOMPCriticalDirective(OMPCriticalDirective *Node) {
819 if (Node->getDirectiveName().getName()) {
821 Node->getDirectiveName().printName(OS, Policy);
824 PrintOMPExecutableDirective(Node);
827 void StmtPrinter::VisitOMPParallelForDirective(OMPParallelForDirective *Node) {
829 PrintOMPExecutableDirective(Node);
833 OMPParallelForSimdDirective *Node) {
835 PrintOMPExecutableDirective(Node);
839 OMPParallelMasterDirective *Node) {
841 PrintOMPExecutableDirective(Node);
845 OMPParallelMaskedDirective *Node) {
847 PrintOMPExecutableDirective(Node);
851 OMPParallelSectionsDirective *Node) {
853 PrintOMPExecutableDirective(Node);
856 void StmtPrinter::VisitOMPTaskDirective(OMPTaskDirective *Node) {
858 PrintOMPExecutableDirective(Node);
861 void StmtPrinter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *Node) {
863 PrintOMPExecutableDirective(Node);
866 void StmtPrinter::VisitOMPBarrierDirective(OMPBarrierDirective *Node) {
868 PrintOMPExecutableDirective(Node);
871 void StmtPrinter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *Node) {
873 PrintOMPExecutableDirective(Node);
876 void StmtPrinter::VisitOMPAssumeDirective(OMPAssumeDirective *Node) {
878 PrintOMPExecutableDirective(Node);
881 void StmtPrinter::VisitOMPErrorDirective(OMPErrorDirective *Node) {
883 PrintOMPExecutableDirective(Node);
886 void StmtPrinter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *Node) {
888 PrintOMPExecutableDirective(Node);
891 void StmtPrinter::VisitOMPFlushDirective(OMPFlushDirective *Node) {
893 PrintOMPExecutableDirective(Node);
896 void StmtPrinter::VisitOMPDepobjDirective(OMPDepobjDirective *Node) {
898 PrintOMPExecutableDirective(Node);
901 void StmtPrinter::VisitOMPScanDirective(OMPScanDirective *Node) {
903 PrintOMPExecutableDirective(Node);
906 void StmtPrinter::VisitOMPOrderedDirective(OMPOrderedDirective *Node) {
908 PrintOMPExecutableDirective(Node, Node->hasClausesOfKind<OMPDependClause>());
911 void StmtPrinter::VisitOMPAtomicDirective(OMPAtomicDirective *Node) {
913 PrintOMPExecutableDirective(Node);
916 void StmtPrinter::VisitOMPTargetDirective(OMPTargetDirective *Node) {
918 PrintOMPExecutableDirective(Node);
921 void StmtPrinter::VisitOMPTargetDataDirective(OMPTargetDataDirective *Node) {
923 PrintOMPExecutableDirective(Node);
927 OMPTargetEnterDataDirective *Node) {
929 PrintOMPExecutableDirective(Node, /*ForceNoStmt=*/true);
933 OMPTargetExitDataDirective *Node) {
935 PrintOMPExecutableDirective(Node, /*ForceNoStmt=*/true);
939 OMPTargetParallelDirective *Node) {
941 PrintOMPExecutableDirective(Node);
945 OMPTargetParallelForDirective *Node) {
947 PrintOMPExecutableDirective(Node);
950 void StmtPrinter::VisitOMPTeamsDirective(OMPTeamsDirective *Node) {
952 PrintOMPExecutableDirective(Node);
956 OMPCancellationPointDirective *Node) {
958 << getOpenMPDirectiveName(Node->getCancelRegion());
959 PrintOMPExecutableDirective(Node);
962 void StmtPrinter::VisitOMPCancelDirective(OMPCancelDirective *Node) {
964 << getOpenMPDirectiveName(Node->getCancelRegion());
965 PrintOMPExecutableDirective(Node);
968 void StmtPrinter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *Node) {
970 PrintOMPExecutableDirective(Node);
974 OMPTaskLoopSimdDirective *Node) {
976 PrintOMPExecutableDirective(Node);
980 OMPMasterTaskLoopDirective *Node) {
982 PrintOMPExecutableDirective(Node);
986 OMPMaskedTaskLoopDirective *Node) {
988 PrintOMPExecutableDirective(Node);
992 OMPMasterTaskLoopSimdDirective *Node) {
994 PrintOMPExecutableDirective(Node);
998 OMPMaskedTaskLoopSimdDirective *Node) {
1000 PrintOMPExecutableDirective(Node);
1004 OMPParallelMasterTaskLoopDirective *Node) {
1006 PrintOMPExecutableDirective(Node);
1010 OMPParallelMaskedTaskLoopDirective *Node) {
1012 PrintOMPExecutableDirective(Node);
1016 OMPParallelMasterTaskLoopSimdDirective *Node) {
1018 PrintOMPExecutableDirective(Node);
1022 OMPParallelMaskedTaskLoopSimdDirective *Node) {
1024 PrintOMPExecutableDirective(Node);
1027 void StmtPrinter::VisitOMPDistributeDirective(OMPDistributeDirective *Node) {
1029 PrintOMPExecutableDirective(Node);
1033 OMPTargetUpdateDirective *Node) {
1035 PrintOMPExecutableDirective(Node, /*ForceNoStmt=*/true);
1039 OMPDistributeParallelForDirective *Node) {
1041 PrintOMPExecutableDirective(Node);
1045 OMPDistributeParallelForSimdDirective *Node) {
1047 PrintOMPExecutableDirective(Node);
1051 OMPDistributeSimdDirective *Node) {
1053 PrintOMPExecutableDirective(Node);
1057 OMPTargetParallelForSimdDirective *Node) {
1059 PrintOMPExecutableDirective(Node);
1062 void StmtPrinter::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *Node) {
1064 PrintOMPExecutableDirective(Node);
1068 OMPTeamsDistributeDirective *Node) {
1070 PrintOMPExecutableDirective(Node);
1074 OMPTeamsDistributeSimdDirective *Node) {
1076 PrintOMPExecutableDirective(Node);
1080 OMPTeamsDistributeParallelForSimdDirective *Node) {
1082 PrintOMPExecutableDirective(Node);
1086 OMPTeamsDistributeParallelForDirective *Node) {
1088 PrintOMPExecutableDirective(Node);
1091 void StmtPrinter::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *Node) {
1093 PrintOMPExecutableDirective(Node);
1097 OMPTargetTeamsDistributeDirective *Node) {
1099 PrintOMPExecutableDirective(Node);
1103 OMPTargetTeamsDistributeParallelForDirective *Node) {
1105 PrintOMPExecutableDirective(Node);
1109 OMPTargetTeamsDistributeParallelForSimdDirective *Node) {
1111 PrintOMPExecutableDirective(Node);
1115 OMPTargetTeamsDistributeSimdDirective *Node) {
1117 PrintOMPExecutableDirective(Node);
1120 void StmtPrinter::VisitOMPInteropDirective(OMPInteropDirective *Node) {
1122 PrintOMPExecutableDirective(Node);
1125 void StmtPrinter::VisitOMPDispatchDirective(OMPDispatchDirective *Node) {
1127 PrintOMPExecutableDirective(Node);
1130 void StmtPrinter::VisitOMPMaskedDirective(OMPMaskedDirective *Node) {
1132 PrintOMPExecutableDirective(Node);
1135 void StmtPrinter::VisitOMPGenericLoopDirective(OMPGenericLoopDirective *Node) {
1137 PrintOMPExecutableDirective(Node);
1141 OMPTeamsGenericLoopDirective *Node) {
1143 PrintOMPExecutableDirective(Node);
1147 OMPTargetTeamsGenericLoopDirective *Node) {
1149 PrintOMPExecutableDirective(Node);
1153 OMPParallelGenericLoopDirective *Node) {
1155 PrintOMPExecutableDirective(Node);
1159 OMPTargetParallelGenericLoopDirective *Node) {
1161 PrintOMPExecutableDirective(Node);
1249 void StmtPrinter::VisitSourceLocExpr(SourceLocExpr *Node) {
1250 OS << Node->getBuiltinStr() << "()";
1253 void StmtPrinter::VisitEmbedExpr(EmbedExpr *Node) {
1257 void StmtPrinter::VisitConstantExpr(ConstantExpr *Node) {
1258 PrintExpr(Node->getSubExpr());
1261 void StmtPrinter::VisitDeclRefExpr(DeclRefExpr *Node) {
1262 ValueDecl *VD = Node->getDecl();
1271 if (NestedNameSpecifier *Qualifier = Node->getQualifier())
1273 if (Node->hasTemplateKeyword())
1275 DeclarationNameInfo NameInfo = Node->getNameInfo();
1300 if (Node->hasExplicitTemplateArgs()) {
1302 if (!Node->hadMultipleCandidates())
1305 printTemplateArgumentList(OS, Node->template_arguments(), Policy, TPL);
1310 DependentScopeDeclRefExpr *Node) {
1311 if (NestedNameSpecifier *Qualifier = Node->getQualifier())
1313 if (Node->hasTemplateKeyword())
1315 OS << Node->getNameInfo();
1316 if (Node->hasExplicitTemplateArgs())
1317 printTemplateArgumentList(OS, Node->template_arguments(), Policy);
1320 void StmtPrinter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *Node) {
1321 if (Node->getQualifier())
1322 Node->getQualifier()->print(OS, Policy);
1323 if (Node->hasTemplateKeyword())
1325 OS << Node->getNameInfo();
1326 if (Node->hasExplicitTemplateArgs())
1327 printTemplateArgumentList(OS, Node->template_arguments(), Policy);
1341 void StmtPrinter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node) {
1342 if (Node->getBase()) {
1344 !isImplicitSelf(Node->getBase()->IgnoreImpCasts())) {
1345 PrintExpr(Node->getBase());
1346 OS << (Node->isArrow() ? "->" : ".");
1349 OS << *Node->getDecl();
1352 void StmtPrinter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node) {
1353 if (Node->isSuperReceiver())
1355 else if (Node->isObjectReceiver() && Node->getBase()) {
1356 PrintExpr(Node->getBase());
1358 } else if (Node->isClassReceiver() && Node->getClassReceiver()) {
1359 OS << Node->getClassReceiver()->getName() << ".";
1362 if (Node->isImplicitProperty()) {
1363 if (const auto *Getter = Node->getImplicitPropertyGetter())
1367 Node->getImplicitPropertySetter()->getSelector());
1369 OS << Node->getExplicitProperty()->getName();
1372 void StmtPrinter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *Node) {
1373 PrintExpr(Node->getBaseExpr());
1375 PrintExpr(Node->getKeyExpr());
1380 SYCLUniqueStableNameExpr *Node) {
1382 Node->getTypeSourceInfo()->getType().print(OS, Policy);
1386 void StmtPrinter::VisitPredefinedExpr(PredefinedExpr *Node) {
1387 OS << PredefinedExpr::getIdentKindName(Node->getIdentKind());
1390 void StmtPrinter::VisitOpenACCAsteriskSizeExpr(OpenACCAsteriskSizeExpr *Node) {
1394 void StmtPrinter::VisitCharacterLiteral(CharacterLiteral *Node) {
1395 CharacterLiteral::print(Node->getValue(), Node->getKind(), OS);
1415 void StmtPrinter::VisitIntegerLiteral(IntegerLiteral *Node) {
1416 if (Policy.ConstantsAsWritten && printExprAsWritten(OS, Node, Context))
1418 bool isSigned = Node->getType()->isSignedIntegerType();
1419 OS << toString(Node->getValue(), 10, isSigned);
1421 if (isa<BitIntType>(Node->getType())) {
1427 switch (Node->getType()->castAs<BuiltinType>()->getKind()) {
1451 void StmtPrinter::VisitFixedPointLiteral(FixedPointLiteral *Node) {
1452 if (Policy.ConstantsAsWritten && printExprAsWritten(OS, Node, Context))
1454 OS << Node->getValueAsString(/*Radix=*/10);
1456 switch (Node->getType()->castAs<BuiltinType>()->getKind()) {
1473 static void PrintFloatingLiteral(raw_ostream &OS, FloatingLiteral *Node,
1476 Node->getValue().toString(Str);
1485 switch (Node->getType()->castAs<BuiltinType>()->getKind()) {
1497 void StmtPrinter::VisitFloatingLiteral(FloatingLiteral *Node) {
1498 if (Policy.ConstantsAsWritten && printExprAsWritten(OS, Node, Context))
1500 PrintFloatingLiteral(OS, Node, /*PrintSuffix=*/true);
1503 void StmtPrinter::VisitImaginaryLiteral(ImaginaryLiteral *Node) {
1504 PrintExpr(Node->getSubExpr());
1512 void StmtPrinter::VisitParenExpr(ParenExpr *Node) {
1514 PrintExpr(Node->getSubExpr());
1518 void StmtPrinter::VisitUnaryOperator(UnaryOperator *Node) {
1519 if (!Node->isPostfix()) {
1520 OS << UnaryOperator::getOpcodeStr(Node->getOpcode());
1524 switch (Node->getOpcode()) {
1533 if (isa<UnaryOperator>(Node->getSubExpr()))
1538 PrintExpr(Node->getSubExpr());
1540 if (Node->isPostfix())
1541 OS << UnaryOperator::getOpcodeStr(Node->getOpcode());
1544 void StmtPrinter::VisitOffsetOfExpr(OffsetOfExpr *Node) {
1546 Node->getTypeSourceInfo()->getType().print(OS, Policy);
1549 for (unsigned i = 0, n = Node->getNumComponents(); i < n; ++i) {
1550 OffsetOfNode ON = Node->getComponent(i);
1554 PrintExpr(Node->getIndexExpr(ON.getArrayExprIndex()));
1579 UnaryExprOrTypeTraitExpr *Node) {
1580 const char *Spelling = getTraitSpelling(Node->getKind());
1581 if (Node->getKind() == UETT_AlignOf) {
1592 if (Node->isArgumentType()) {
1594 Node->getArgumentType().print(OS, Policy);
1598 PrintExpr(Node->getArgumentExpr());
1602 void StmtPrinter::VisitGenericSelectionExpr(GenericSelectionExpr *Node) {
1604 if (Node->isExprPredicate())
1605 PrintExpr(Node->getControllingExpr());
1607 Node->getControllingType()->getType().print(OS, Policy);
1609 for (const GenericSelectionExpr::Association &Assoc : Node->associations()) {
1622 void StmtPrinter::VisitArraySubscriptExpr(ArraySubscriptExpr *Node) {
1623 PrintExpr(Node->getLHS());
1625 PrintExpr(Node->getRHS());
1629 void StmtPrinter::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *Node) {
1630 PrintExpr(Node->getBase());
1632 PrintExpr(Node->getRowIdx());
1635 PrintExpr(Node->getColumnIdx());
1639 void StmtPrinter::VisitArraySectionExpr(ArraySectionExpr *Node) {
1640 PrintExpr(Node->getBase());
1642 if (Node->getLowerBound())
1643 PrintExpr(Node->getLowerBound());
1644 if (Node->getColonLocFirst().isValid()) {
1646 if (Node->getLength())
1647 PrintExpr(Node->getLength());
1649 if (Node->isOMPArraySection() && Node->getColonLocSecond().isValid()) {
1651 if (Node->getStride())
1652 PrintExpr(Node->getStride());
1657 void StmtPrinter::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *Node) {
1659 for (Expr *E : Node->getDimensions()) {
1665 PrintExpr(Node->getBase());
1668 void StmtPrinter::VisitOMPIteratorExpr(OMPIteratorExpr *Node) {
1670 for (unsigned I = 0, E = Node->numOfIterators(); I < E; ++I) {
1671 auto *VD = cast<ValueDecl>(Node->getIteratorDecl(I));
1673 const OMPIteratorExpr::IteratorRange Range = Node->getIteratorRange(I);
1713 void StmtPrinter::VisitMemberExpr(MemberExpr *Node) {
1714 if (!Policy.SuppressImplicitBase || !isImplicitThis(Node->getBase())) {
1715 PrintExpr(Node->getBase());
1717 auto *ParentMember = dyn_cast<MemberExpr>(Node->getBase());
1723 OS << (Node->isArrow() ? "->" : ".");
1726 if (auto *FD = dyn_cast<FieldDecl>(Node->getMemberDecl()))
1730 if (NestedNameSpecifier *Qualifier = Node->getQualifier())
1732 if (Node->hasTemplateKeyword())
1734 OS << Node->getMemberNameInfo();
1736 if (auto *FD = dyn_cast<FunctionDecl>(Node->getMemberDecl())) {
1737 if (!Node->hadMultipleCandidates())
1741 dyn_cast<VarTemplateSpecializationDecl>(Node->getMemberDecl()))
1743 if (Node->hasExplicitTemplateArgs())
1744 printTemplateArgumentList(OS, Node->template_arguments(), Policy, TPL);
1747 void StmtPrinter::VisitObjCIsaExpr(ObjCIsaExpr *Node) {
1748 PrintExpr(Node->getBase());
1749 OS << (Node->isArrow() ? "->isa" : ".isa");
1752 void StmtPrinter::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) {
1753 PrintExpr(Node->getBase());
1755 OS << Node->getAccessor().getName();
1758 void StmtPrinter::VisitCStyleCastExpr(CStyleCastExpr *Node) {
1760 Node->getTypeAsWritten().print(OS, Policy);
1762 PrintExpr(Node->getSubExpr());
1765 void StmtPrinter::VisitCompoundLiteralExpr(CompoundLiteralExpr *Node) {
1767 Node->getType().print(OS, Policy);
1769 PrintExpr(Node->getInitializer());
1772 void StmtPrinter::VisitImplicitCastExpr(ImplicitCastExpr *Node) {
1774 PrintExpr(Node->getSubExpr());
1777 void StmtPrinter::VisitBinaryOperator(BinaryOperator *Node) {
1778 PrintExpr(Node->getLHS());
1779 OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
1780 PrintExpr(Node->getRHS());
1783 void StmtPrinter::VisitCompoundAssignOperator(CompoundAssignOperator *Node) {
1784 PrintExpr(Node->getLHS());
1785 OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
1786 PrintExpr(Node->getRHS());
1789 void StmtPrinter::VisitConditionalOperator(ConditionalOperator *Node) {
1790 PrintExpr(Node->getCond());
1792 PrintExpr(Node->getLHS());
1794 PrintExpr(Node->getRHS());
1800 StmtPrinter::VisitBinaryConditionalOperator(BinaryConditionalOperator *Node) {
1801 PrintExpr(Node->getCommon());
1803 PrintExpr(Node->getFalseExpr());
1806 void StmtPrinter::VisitAddrLabelExpr(AddrLabelExpr *Node) {
1807 OS << "&&" << Node->getLabel()->getName();
1816 void StmtPrinter::VisitChooseExpr(ChooseExpr *Node) {
1818 PrintExpr(Node->getCond());
1820 PrintExpr(Node->getLHS());
1822 PrintExpr(Node->getRHS());
1830 void StmtPrinter::VisitShuffleVectorExpr(ShuffleVectorExpr *Node) {
1832 for (unsigned i = 0, e = Node->getNumSubExprs(); i != e; ++i) {
1834 PrintExpr(Node->getExpr(i));
1839 void StmtPrinter::VisitConvertVectorExpr(ConvertVectorExpr *Node) {
1841 PrintExpr(Node->getSrcExpr());
1843 Node->getType().print(OS, Policy);
1847 void StmtPrinter::VisitInitListExpr(InitListExpr* Node) {
1848 if (Node->getSyntacticForm()) {
1849 Visit(Node->getSyntacticForm());
1854 for (unsigned i = 0, e = Node->getNumInits(); i != e; ++i) {
1856 if (Node->getInit(i))
1857 PrintExpr(Node->getInit(i));
1864 void StmtPrinter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *Node) {
1868 PrintExpr(Node->getSubExpr());
1872 void StmtPrinter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *Node) {
1876 void StmtPrinter::VisitParenListExpr(ParenListExpr* Node) {
1878 for (unsigned i = 0, e = Node->getNumExprs(); i != e; ++i) {
1880 PrintExpr(Node->getExpr(i));
1885 void StmtPrinter::VisitDesignatedInitExpr(DesignatedInitExpr *Node) {
1887 for (const DesignatedInitExpr::Designator &D : Node->designators()) {
1900 PrintExpr(Node->getArrayIndex(D));
1902 PrintExpr(Node->getArrayRangeStart(D));
1904 PrintExpr(Node->getArrayRangeEnd(D));
1914 PrintExpr(Node->getInit());
1918 DesignatedInitUpdateExpr *Node) {
1921 PrintExpr(Node->getBase());
1925 PrintExpr(Node->getUpdater());
1929 void StmtPrinter::VisitNoInitExpr(NoInitExpr *Node) {
1933 void StmtPrinter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *Node) {
1934 if (Node->getType()->getAsCXXRecordDecl()) {
1936 Node->getType().print(OS, Policy);
1940 Node->getType().print(OS, Policy);
1942 if (Node->getType()->isRecordType())
1949 void StmtPrinter::VisitVAArgExpr(VAArgExpr *Node) {
1951 PrintExpr(Node->getSubExpr());
1953 Node->getType().print(OS, Policy);
1957 void StmtPrinter::VisitPseudoObjectExpr(PseudoObjectExpr *Node) {
1958 PrintExpr(Node->getSyntacticForm());
1961 void StmtPrinter::VisitAtomicExpr(AtomicExpr *Node) {
1963 switch (Node->getOp()) {
1974 PrintExpr(Node->getPtr());
1975 if (Node->getOp() != AtomicExpr::AO__c11_atomic_load &&
1976 Node->getOp() != AtomicExpr::AO__atomic_load_n &&
1977 Node->getOp() != AtomicExpr::AO__scoped_atomic_load_n &&
1978 Node->getOp() != AtomicExpr::AO__opencl_atomic_load &&
1979 Node->getOp() != AtomicExpr::AO__hip_atomic_load) {
1981 PrintExpr(Node->getVal1());
1983 if (Node->getOp() == AtomicExpr::AO__atomic_exchange ||
1984 Node->isCmpXChg()) {
1986 PrintExpr(Node->getVal2());
1988 if (Node->getOp() == AtomicExpr::AO__atomic_compare_exchange ||
1989 Node->getOp() == AtomicExpr::AO__atomic_compare_exchange_n) {
1991 PrintExpr(Node->getWeak());
1993 if (Node->getOp() != AtomicExpr::AO__c11_atomic_init &&
1994 Node->getOp() != AtomicExpr::AO__opencl_atomic_init) {
1996 PrintExpr(Node->getOrder());
1998 if (Node->isCmpXChg()) {
2000 PrintExpr(Node->getOrderFail());
2006 void StmtPrinter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *Node) {
2007 OverloadedOperatorKind Kind = Node->getOperator();
2009 if (Node->getNumArgs() == 1) {
2011 PrintExpr(Node->getArg(0));
2013 PrintExpr(Node->getArg(0));
2017 PrintExpr(Node->getArg(0));
2019 PrintExpr(Node->getArg(0));
2021 for (unsigned ArgIdx = 1; ArgIdx < Node->getNumArgs(); ++ArgIdx) {
2024 if (!isa<CXXDefaultArgExpr>(Node->getArg(ArgIdx)))
2025 PrintExpr(Node->getArg(ArgIdx));
2028 } else if (Node->getNumArgs() == 1) {
2030 PrintExpr(Node->getArg(0));
2031 } else if (Node->getNumArgs() == 2) {
2032 PrintExpr(Node->getArg(0));
2034 PrintExpr(Node->getArg(1));
2040 void StmtPrinter::VisitCXXMemberCallExpr(CXXMemberCallExpr *Node) {
2042 CXXMethodDecl *MD = Node->getMethodDecl();
2044 PrintExpr(Node->getImplicitObjectArgument());
2047 VisitCallExpr(cast<CallExpr>(Node));
2050 void StmtPrinter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *Node) {
2051 PrintExpr(Node->getCallee());
2053 PrintCallArgs(Node->getConfig());
2055 PrintCallArgs(Node);
2060 CXXRewrittenBinaryOperator *Node) {
2062 Node->getDecomposedForm();
2068 void StmtPrinter::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) {
2069 OS << Node->getCastName() << '<';
2070 Node->getTypeAsWritten().print(OS, Policy);
2072 PrintExpr(Node->getSubExpr());
2076 void StmtPrinter::VisitCXXStaticCastExpr(CXXStaticCastExpr *Node) {
2077 VisitCXXNamedCastExpr(Node);
2080 void StmtPrinter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *Node) {
2081 VisitCXXNamedCastExpr(Node);
2084 void StmtPrinter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *Node) {
2085 VisitCXXNamedCastExpr(Node);
2088 void StmtPrinter::VisitCXXConstCastExpr(CXXConstCastExpr *Node) {
2089 VisitCXXNamedCastExpr(Node);
2092 void StmtPrinter::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *Node) {
2094 Node->getTypeInfoAsWritten()->getType().print(OS, Policy);
2096 PrintExpr(Node->getSubExpr());
2100 void StmtPrinter::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *Node) {
2101 VisitCXXNamedCastExpr(Node);
2104 void StmtPrinter::VisitCXXTypeidExpr(CXXTypeidExpr *Node) {
2106 if (Node->isTypeOperand()) {
2107 Node->getTypeOperandSourceInfo()->getType().print(OS, Policy);
2109 PrintExpr(Node->getExprOperand());
2114 void StmtPrinter::VisitCXXUuidofExpr(CXXUuidofExpr *Node) {
2116 if (Node->isTypeOperand()) {
2117 Node->getTypeOperandSourceInfo()->getType().print(OS, Policy);
2119 PrintExpr(Node->getExprOperand());
2124 void StmtPrinter::VisitMSPropertyRefExpr(MSPropertyRefExpr *Node) {
2125 PrintExpr(Node->getBaseExpr());
2126 if (Node->isArrow())
2131 Node->getQualifierLoc().getNestedNameSpecifier())
2133 OS << Node->getPropertyDecl()->getDeclName();
2136 void StmtPrinter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *Node) {
2137 PrintExpr(Node->getBase());
2139 PrintExpr(Node->getIdx());
2143 void StmtPrinter::VisitUserDefinedLiteral(UserDefinedLiteral *Node) {
2144 switch (Node->getLiteralOperatorKind()) {
2146 OS << cast<StringLiteral>(Node->getArg(0)->IgnoreImpCasts())->getString();
2149 const auto *DRE = cast<DeclRefExpr>(Node->getCallee()->IgnoreImpCasts());
2159 OS << "operator\"\"" << Node->getUDSuffix()->getName();
2174 const auto *Int = cast<IntegerLiteral>(Node->getCookedLiteral());
2180 auto *Float = cast<FloatingLiteral>(Node->getCookedLiteral());
2186 PrintExpr(Node->getCookedLiteral());
2189 OS << Node->getUDSuffix()->getName();
2192 void StmtPrinter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) {
2193 OS << (Node->getValue() ? "true" : "false");
2196 void StmtPrinter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *Node) {
2200 void StmtPrinter::VisitCXXThisExpr(CXXThisExpr *Node) {
2204 void StmtPrinter::VisitCXXThrowExpr(CXXThrowExpr *Node) {
2205 if (!Node->getSubExpr())
2209 PrintExpr(Node->getSubExpr());
2213 void StmtPrinter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *Node) {
2217 void StmtPrinter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *Node) {
2221 void StmtPrinter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) {
2222 auto TargetType = Node->getType();
2234 if (!Node->isListInitialization())
2236 PrintExpr(Node->getSubExpr());
2237 if (!Node->isListInitialization())
2241 void StmtPrinter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node) {
2242 PrintExpr(Node->getSubExpr());
2245 void StmtPrinter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *Node) {
2246 Node->getType().print(OS, Policy);
2247 if (Node->isStdInitListInitialization())
2249 else if (Node->isListInitialization())
2253 for (CXXTemporaryObjectExpr::arg_iterator Arg = Node->arg_begin(),
2254 ArgEnd = Node->arg_end();
2258 if (Arg != Node->arg_begin())
2262 if (Node->isStdInitListInitialization())
2264 else if (Node->isListInitialization())
2270 void StmtPrinter::VisitLambdaExpr(LambdaExpr *Node) {
2273 switch (Node->getCaptureDefault()) {
2287 for (LambdaExpr::capture_iterator C = Node->explicit_capture_begin(),
2288 CEnd = Node->explicit_capture_end();
2308 if (Node->getCaptureDefault() != LCD_ByRef || Node->isInitCapture(C))
2324 if (Node->isInitCapture(C)) {
2345 if (!Node->getExplicitTemplateParameters().empty()) {
2346 Node->getTemplateParameterList()->print(
2347 OS, Node->getLambdaClass()->getASTContext(),
2351 if (Node->hasExplicitParameters()) {
2353 CXXMethodDecl *Method = Node->getCallOperator();
2374 if (Node->isMutable())
2383 if (Node->hasExplicitResultType()) {
2394 PrintRawCompoundStmt(Node->getCompoundStmtBody());
2397 void StmtPrinter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *Node) {
2398 if (TypeSourceInfo *TSInfo = Node->getTypeSourceInfo())
2401 Node->getType().print(OS, Policy);
2505 CXXUnresolvedConstructExpr *Node) {
2506 Node->getTypeAsWritten().print(OS, Policy);
2507 if (!Node->isListInitialization())
2509 for (auto Arg = Node->arg_begin(), ArgEnd = Node->arg_end(); Arg != ArgEnd;
2511 if (Arg != Node->arg_begin())
2515 if (!Node->isListInitialization())
2520 CXXDependentScopeMemberExpr *Node) {
2521 if (!Node->isImplicitAccess()) {
2522 PrintExpr(Node->getBase());
2523 OS << (Node->isArrow() ? "->" : ".");
2525 if (NestedNameSpecifier *Qualifier = Node->getQualifier())
2527 if (Node->hasTemplateKeyword())
2529 OS << Node->getMemberNameInfo();
2530 if (Node->hasExplicitTemplateArgs())
2531 printTemplateArgumentList(OS, Node->template_arguments(), Policy);
2534 void StmtPrinter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *Node) {
2535 if (!Node->isImplicitAccess()) {
2536 PrintExpr(Node->getBase());
2537 OS << (Node->isArrow() ? "->" : ".");
2539 if (NestedNameSpecifier *Qualifier = Node->getQualifier())
2541 if (Node->hasTemplateKeyword())
2543 OS << Node->getMemberNameInfo();
2544 if (Node->hasExplicitTemplateArgs())
2545 printTemplateArgumentList(OS, Node->template_arguments(), Policy);
2602 SubstNonTypeTemplateParmPackExpr *Node) {
2603 OS << *Node->getParameterPack();
2607 SubstNonTypeTemplateParmExpr *Node) {
2608 Visit(Node->getReplacement());
2615 void StmtPrinter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *Node){
2616 PrintExpr(Node->getSubExpr());
2633 void StmtPrinter::VisitCXXParenListInitExpr(CXXParenListInitExpr *Node) {
2635 llvm::interleaveComma(Node->getInitExprs(), OS,
2738 void StmtPrinter::VisitObjCStringLiteral(ObjCStringLiteral *Node) {
2740 VisitStringLiteral(Node->getString());
2775 void StmtPrinter::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) {
2777 Node->getEncodedType().print(OS, Policy);
2781 void StmtPrinter::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) {
2783 Node->getSelector().print(OS);
2787 void StmtPrinter::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) {
2788 OS << "@protocol(" << *Node->getProtocol() << ')';
2829 void StmtPrinter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *Node) {
2830 OS << (Node->getValue() ? "__objc_yes" : "__objc_no");
2846 void StmtPrinter::VisitBlockExpr(BlockExpr *Node) {
2847 BlockDecl *BD = Node->getBlockDecl();
2850 const FunctionType *AFT = Node->getFunctionType();
2873 void StmtPrinter::VisitOpaqueValueExpr(OpaqueValueExpr *Node) {
2874 PrintExpr(Node->getSourceExpr());
2877 void StmtPrinter::VisitTypoExpr(TypoExpr *Node) {
2882 void StmtPrinter::VisitRecoveryExpr(RecoveryExpr *Node) {
2885 for (Expr *E : Node->subExpressions()) {
2893 void StmtPrinter::VisitAsTypeExpr(AsTypeExpr *Node) {
2895 PrintExpr(Node->getSrcExpr());
2897 Node->getType().print(OS, Policy);
2901 void StmtPrinter::VisitHLSLOutArgExpr(HLSLOutArgExpr *Node) {
2902 PrintExpr(Node->getArgLValue());