StmtPrinter.cpp | Explore in Territory

//===- StmtPrinter.cpp - Printing implementation for Stmt ASTs ------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file implements the Stmt::dumpPretty/Stmt::printPretty methods, which
// pretty print the AST back out to C code.
//
//===----------------------------------------------------------------------===//

#include "clang/AST/ASTContext.h"
#include "clang/AST/Attr.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclBase.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/DeclOpenMP.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/Expr.h"
#include "clang/AST/ExprCXX.h"
#include "clang/AST/ExprObjC.h"
#include "clang/AST/ExprOpenMP.h"
#include "clang/AST/NestedNameSpecifier.h"
#include "clang/AST/OpenMPClause.h"
#include "clang/AST/PrettyPrinter.h"
#include "clang/AST/Stmt.h"
#include "clang/AST/StmtCXX.h"
#include "clang/AST/StmtObjC.h"
#include "clang/AST/StmtOpenMP.h"
#include "clang/AST/StmtVisitor.h"
#include "clang/AST/TemplateBase.h"
#include "clang/AST/Type.h"
#include "clang/Basic/CharInfo.h"
#include "clang/Basic/ExpressionTraits.h"
#include "clang/Basic/IdentifierTable.h"
#include "clang/Basic/JsonSupport.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/Lambda.h"
#include "clang/Basic/OpenMPKinds.h"
#include "clang/Basic/OperatorKinds.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/TypeTraits.h"
#include "clang/Lex/Lexer.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>
#include <optional>
#include <string>

usingnamespaceclang;

//===----------------------------------------------------------------------===//
// StmtPrinter Visitor
//===----------------------------------------------------------------------===//

namespace {

  class StmtPrinter : public StmtVisitor<StmtPrinter> { … };

} // namespace

//===----------------------------------------------------------------------===//
//  Stmt printing methods.
//===----------------------------------------------------------------------===//

/// PrintRawCompoundStmt - Print a compound stmt without indenting the {, and
/// with no newline after the }.
void StmtPrinter::PrintRawCompoundStmt(CompoundStmt *Node) { … }

void StmtPrinter::PrintFPPragmas(CompoundStmt *S) { … }

void StmtPrinter::PrintRawDecl(Decl *D) { … }

void StmtPrinter::PrintRawDeclStmt(const DeclStmt *S) { … }

void StmtPrinter::VisitNullStmt(NullStmt *Node) { … }

void StmtPrinter::VisitDeclStmt(DeclStmt *Node) { … }

void StmtPrinter::VisitCompoundStmt(CompoundStmt *Node) { … }

void StmtPrinter::VisitCaseStmt(CaseStmt *Node) { … }

void StmtPrinter::VisitDefaultStmt(DefaultStmt *Node) { … }

void StmtPrinter::VisitLabelStmt(LabelStmt *Node) { … }

void StmtPrinter::VisitAttributedStmt(AttributedStmt *Node) { … }

void StmtPrinter::PrintRawIfStmt(IfStmt *If) { … }

void StmtPrinter::VisitIfStmt(IfStmt *If) { … }

void StmtPrinter::VisitSwitchStmt(SwitchStmt *Node) { … }

void StmtPrinter::VisitWhileStmt(WhileStmt *Node) { … }

void StmtPrinter::VisitDoStmt(DoStmt *Node) { … }

void StmtPrinter::VisitForStmt(ForStmt *Node) { … }

void StmtPrinter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *Node) { … }

void StmtPrinter::VisitCXXForRangeStmt(CXXForRangeStmt *Node) { … }

void StmtPrinter::VisitMSDependentExistsStmt(MSDependentExistsStmt *Node) { … }

void StmtPrinter::VisitGotoStmt(GotoStmt *Node) { … }

void StmtPrinter::VisitIndirectGotoStmt(IndirectGotoStmt *Node) { … }

void StmtPrinter::VisitContinueStmt(ContinueStmt *Node) { … }

void StmtPrinter::VisitBreakStmt(BreakStmt *Node) { … }

void StmtPrinter::VisitReturnStmt(ReturnStmt *Node) { … }

void StmtPrinter::VisitGCCAsmStmt(GCCAsmStmt *Node) { … }

void StmtPrinter::VisitMSAsmStmt(MSAsmStmt *Node) { … }

void StmtPrinter::VisitCapturedStmt(CapturedStmt *Node) { … }

void StmtPrinter::VisitObjCAtTryStmt(ObjCAtTryStmt *Node) { … }

void StmtPrinter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *Node) { … }

void StmtPrinter::VisitObjCAtCatchStmt (ObjCAtCatchStmt *Node) { … }

void StmtPrinter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *Node) { … }

void StmtPrinter::VisitObjCAvailabilityCheckExpr(
    ObjCAvailabilityCheckExpr *Node) { … }

void StmtPrinter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *Node) { … }

void StmtPrinter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *Node) { … }

void StmtPrinter::PrintRawCXXCatchStmt(CXXCatchStmt *Node) { … }

void StmtPrinter::VisitCXXCatchStmt(CXXCatchStmt *Node) { … }

void StmtPrinter::VisitCXXTryStmt(CXXTryStmt *Node) { … }

void StmtPrinter::VisitSEHTryStmt(SEHTryStmt *Node) { … }

void StmtPrinter::PrintRawSEHFinallyStmt(SEHFinallyStmt *Node) { … }

void StmtPrinter::PrintRawSEHExceptHandler(SEHExceptStmt *Node) { … }

void StmtPrinter::VisitSEHExceptStmt(SEHExceptStmt *Node) { … }

void StmtPrinter::VisitSEHFinallyStmt(SEHFinallyStmt *Node) { … }

void StmtPrinter::VisitSEHLeaveStmt(SEHLeaveStmt *Node) { … }

//===----------------------------------------------------------------------===//
//  OpenMP directives printing methods
//===----------------------------------------------------------------------===//

void StmtPrinter::VisitOMPCanonicalLoop(OMPCanonicalLoop *Node) { … }

void StmtPrinter::PrintOMPExecutableDirective(OMPExecutableDirective *S,
                                              bool ForceNoStmt) { … }

void StmtPrinter::VisitOMPMetaDirective(OMPMetaDirective *Node) { … }

void StmtPrinter::VisitOMPParallelDirective(OMPParallelDirective *Node) { … }

void StmtPrinter::VisitOMPSimdDirective(OMPSimdDirective *Node) { … }

void StmtPrinter::VisitOMPTileDirective(OMPTileDirective *Node) { … }

void StmtPrinter::VisitOMPUnrollDirective(OMPUnrollDirective *Node) { … }

void StmtPrinter::VisitOMPReverseDirective(OMPReverseDirective *Node) { … }

void StmtPrinter::VisitOMPInterchangeDirective(OMPInterchangeDirective *Node) { … }

void StmtPrinter::VisitOMPForDirective(OMPForDirective *Node) { … }

void StmtPrinter::VisitOMPForSimdDirective(OMPForSimdDirective *Node) { … }

void StmtPrinter::VisitOMPSectionsDirective(OMPSectionsDirective *Node) { … }

void StmtPrinter::VisitOMPSectionDirective(OMPSectionDirective *Node) { … }

void StmtPrinter::VisitOMPScopeDirective(OMPScopeDirective *Node) { … }

void StmtPrinter::VisitOMPSingleDirective(OMPSingleDirective *Node) { … }

void StmtPrinter::VisitOMPMasterDirective(OMPMasterDirective *Node) { … }

void StmtPrinter::VisitOMPCriticalDirective(OMPCriticalDirective *Node) { … }

void StmtPrinter::VisitOMPParallelForDirective(OMPParallelForDirective *Node) { … }

void StmtPrinter::VisitOMPParallelForSimdDirective(
    OMPParallelForSimdDirective *Node) { … }

void StmtPrinter::VisitOMPParallelMasterDirective(
    OMPParallelMasterDirective *Node) { … }

void StmtPrinter::VisitOMPParallelMaskedDirective(
    OMPParallelMaskedDirective *Node) { … }

void StmtPrinter::VisitOMPParallelSectionsDirective(
    OMPParallelSectionsDirective *Node) { … }

void StmtPrinter::VisitOMPTaskDirective(OMPTaskDirective *Node) { … }

void StmtPrinter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *Node) { … }

void StmtPrinter::VisitOMPBarrierDirective(OMPBarrierDirective *Node) { … }

void StmtPrinter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *Node) { … }

void StmtPrinter::VisitOMPAssumeDirective(OMPAssumeDirective *Node) { … }

void StmtPrinter::VisitOMPErrorDirective(OMPErrorDirective *Node) { … }

void StmtPrinter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *Node) { … }

void StmtPrinter::VisitOMPFlushDirective(OMPFlushDirective *Node) { … }

void StmtPrinter::VisitOMPDepobjDirective(OMPDepobjDirective *Node) { … }

void StmtPrinter::VisitOMPScanDirective(OMPScanDirective *Node) { … }

void StmtPrinter::VisitOMPOrderedDirective(OMPOrderedDirective *Node) { … }

void StmtPrinter::VisitOMPAtomicDirective(OMPAtomicDirective *Node) { … }

void StmtPrinter::VisitOMPTargetDirective(OMPTargetDirective *Node) { … }

void StmtPrinter::VisitOMPTargetDataDirective(OMPTargetDataDirective *Node) { … }

void StmtPrinter::VisitOMPTargetEnterDataDirective(
    OMPTargetEnterDataDirective *Node) { … }

void StmtPrinter::VisitOMPTargetExitDataDirective(
    OMPTargetExitDataDirective *Node) { … }

void StmtPrinter::VisitOMPTargetParallelDirective(
    OMPTargetParallelDirective *Node) { … }

void StmtPrinter::VisitOMPTargetParallelForDirective(
    OMPTargetParallelForDirective *Node) { … }

void StmtPrinter::VisitOMPTeamsDirective(OMPTeamsDirective *Node) { … }

void StmtPrinter::VisitOMPCancellationPointDirective(
    OMPCancellationPointDirective *Node) { … }

void StmtPrinter::VisitOMPCancelDirective(OMPCancelDirective *Node) { … }

void StmtPrinter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *Node) { … }

void StmtPrinter::VisitOMPTaskLoopSimdDirective(
    OMPTaskLoopSimdDirective *Node) { … }

void StmtPrinter::VisitOMPMasterTaskLoopDirective(
    OMPMasterTaskLoopDirective *Node) { … }

void StmtPrinter::VisitOMPMaskedTaskLoopDirective(
    OMPMaskedTaskLoopDirective *Node) { … }

void StmtPrinter::VisitOMPMasterTaskLoopSimdDirective(
    OMPMasterTaskLoopSimdDirective *Node) { … }

void StmtPrinter::VisitOMPMaskedTaskLoopSimdDirective(
    OMPMaskedTaskLoopSimdDirective *Node) { … }

void StmtPrinter::VisitOMPParallelMasterTaskLoopDirective(
    OMPParallelMasterTaskLoopDirective *Node) { … }

void StmtPrinter::VisitOMPParallelMaskedTaskLoopDirective(
    OMPParallelMaskedTaskLoopDirective *Node) { … }

void StmtPrinter::VisitOMPParallelMasterTaskLoopSimdDirective(
    OMPParallelMasterTaskLoopSimdDirective *Node) { … }

void StmtPrinter::VisitOMPParallelMaskedTaskLoopSimdDirective(
    OMPParallelMaskedTaskLoopSimdDirective *Node) { … }

void StmtPrinter::VisitOMPDistributeDirective(OMPDistributeDirective *Node) { … }

void StmtPrinter::VisitOMPTargetUpdateDirective(
    OMPTargetUpdateDirective *Node) { … }

void StmtPrinter::VisitOMPDistributeParallelForDirective(
    OMPDistributeParallelForDirective *Node) { … }

void StmtPrinter::VisitOMPDistributeParallelForSimdDirective(
    OMPDistributeParallelForSimdDirective *Node) { … }

void StmtPrinter::VisitOMPDistributeSimdDirective(
    OMPDistributeSimdDirective *Node) { … }

void StmtPrinter::VisitOMPTargetParallelForSimdDirective(
    OMPTargetParallelForSimdDirective *Node) { … }

void StmtPrinter::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *Node) { … }

void StmtPrinter::VisitOMPTeamsDistributeDirective(
    OMPTeamsDistributeDirective *Node) { … }

void StmtPrinter::VisitOMPTeamsDistributeSimdDirective(
    OMPTeamsDistributeSimdDirective *Node) { … }

void StmtPrinter::VisitOMPTeamsDistributeParallelForSimdDirective(
    OMPTeamsDistributeParallelForSimdDirective *Node) { … }

void StmtPrinter::VisitOMPTeamsDistributeParallelForDirective(
    OMPTeamsDistributeParallelForDirective *Node) { … }

void StmtPrinter::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *Node) { … }

void StmtPrinter::VisitOMPTargetTeamsDistributeDirective(
    OMPTargetTeamsDistributeDirective *Node) { … }

void StmtPrinter::VisitOMPTargetTeamsDistributeParallelForDirective(
    OMPTargetTeamsDistributeParallelForDirective *Node) { … }

void StmtPrinter::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
    OMPTargetTeamsDistributeParallelForSimdDirective *Node) { … }

void StmtPrinter::VisitOMPTargetTeamsDistributeSimdDirective(
    OMPTargetTeamsDistributeSimdDirective *Node) { … }

void StmtPrinter::VisitOMPInteropDirective(OMPInteropDirective *Node) { … }

void StmtPrinter::VisitOMPDispatchDirective(OMPDispatchDirective *Node) { … }

void StmtPrinter::VisitOMPMaskedDirective(OMPMaskedDirective *Node) { … }

void StmtPrinter::VisitOMPGenericLoopDirective(OMPGenericLoopDirective *Node) { … }

void StmtPrinter::VisitOMPTeamsGenericLoopDirective(
    OMPTeamsGenericLoopDirective *Node) { … }

void StmtPrinter::VisitOMPTargetTeamsGenericLoopDirective(
    OMPTargetTeamsGenericLoopDirective *Node) { … }

void StmtPrinter::VisitOMPParallelGenericLoopDirective(
    OMPParallelGenericLoopDirective *Node) { … }

void StmtPrinter::VisitOMPTargetParallelGenericLoopDirective(
    OMPTargetParallelGenericLoopDirective *Node) { … }

//===----------------------------------------------------------------------===//
//  OpenACC construct printing methods
//===----------------------------------------------------------------------===//
void StmtPrinter::VisitOpenACCComputeConstruct(OpenACCComputeConstruct *S) { … }

void StmtPrinter::VisitOpenACCLoopConstruct(OpenACCLoopConstruct *S) { … }

//===----------------------------------------------------------------------===//
//  Expr printing methods.
//===----------------------------------------------------------------------===//

void StmtPrinter::VisitSourceLocExpr(SourceLocExpr *Node) { … }

void StmtPrinter::VisitEmbedExpr(EmbedExpr *Node) { … }

void StmtPrinter::VisitConstantExpr(ConstantExpr *Node) { … }

void StmtPrinter::VisitDeclRefExpr(DeclRefExpr *Node) { … }

void StmtPrinter::VisitDependentScopeDeclRefExpr(
                                           DependentScopeDeclRefExpr *Node) { … }

void StmtPrinter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *Node) { … }

static bool isImplicitSelf(const Expr *E) { … }

void StmtPrinter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node) { … }

void StmtPrinter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node) { … }

void StmtPrinter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *Node) { … }

void StmtPrinter::VisitSYCLUniqueStableNameExpr(
    SYCLUniqueStableNameExpr *Node) { … }

void StmtPrinter::VisitPredefinedExpr(PredefinedExpr *Node) { … }

void StmtPrinter::VisitCharacterLiteral(CharacterLiteral *Node) { … }

/// Prints the given expression using the original source text. Returns true on
/// success, false otherwise.
static bool printExprAsWritten(raw_ostream &OS, Expr *E,
                               const ASTContext *Context) { … }

void StmtPrinter::VisitIntegerLiteral(IntegerLiteral *Node) { … }

void StmtPrinter::VisitFixedPointLiteral(FixedPointLiteral *Node) { … }

static void PrintFloatingLiteral(raw_ostream &OS, FloatingLiteral *Node,
                                 bool PrintSuffix) { … }

void StmtPrinter::VisitFloatingLiteral(FloatingLiteral *Node) { … }

void StmtPrinter::VisitImaginaryLiteral(ImaginaryLiteral *Node) { … }

void StmtPrinter::VisitStringLiteral(StringLiteral *Str) { … }

void StmtPrinter::VisitParenExpr(ParenExpr *Node) { … }

void StmtPrinter::VisitUnaryOperator(UnaryOperator *Node) { … }

void StmtPrinter::VisitOffsetOfExpr(OffsetOfExpr *Node) { … }

void StmtPrinter::VisitUnaryExprOrTypeTraitExpr(
    UnaryExprOrTypeTraitExpr *Node) { … }

void StmtPrinter::VisitGenericSelectionExpr(GenericSelectionExpr *Node) { … }

void StmtPrinter::VisitArraySubscriptExpr(ArraySubscriptExpr *Node) { … }

void StmtPrinter::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *Node) { … }

void StmtPrinter::VisitArraySectionExpr(ArraySectionExpr *Node) { … }

void StmtPrinter::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *Node) { … }

void StmtPrinter::VisitOMPIteratorExpr(OMPIteratorExpr *Node) { … }

void StmtPrinter::PrintCallArgs(CallExpr *Call) { … }

void StmtPrinter::VisitCallExpr(CallExpr *Call) { … }

static bool isImplicitThis(const Expr *E) { … }

void StmtPrinter::VisitMemberExpr(MemberExpr *Node) { … }

void StmtPrinter::VisitObjCIsaExpr(ObjCIsaExpr *Node) { … }

void StmtPrinter::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) { … }

void StmtPrinter::VisitCStyleCastExpr(CStyleCastExpr *Node) { … }

void StmtPrinter::VisitCompoundLiteralExpr(CompoundLiteralExpr *Node) { … }

void StmtPrinter::VisitImplicitCastExpr(ImplicitCastExpr *Node) { … }

void StmtPrinter::VisitBinaryOperator(BinaryOperator *Node) { … }

void StmtPrinter::VisitCompoundAssignOperator(CompoundAssignOperator *Node) { … }

void StmtPrinter::VisitConditionalOperator(ConditionalOperator *Node) { … }

// GNU extensions.

void
StmtPrinter::VisitBinaryConditionalOperator(BinaryConditionalOperator *Node) { … }

void StmtPrinter::VisitAddrLabelExpr(AddrLabelExpr *Node) { … }

void StmtPrinter::VisitStmtExpr(StmtExpr *E) { … }

void StmtPrinter::VisitChooseExpr(ChooseExpr *Node) { … }

void StmtPrinter::VisitGNUNullExpr(GNUNullExpr *) { … }

void StmtPrinter::VisitShuffleVectorExpr(ShuffleVectorExpr *Node) { … }

void StmtPrinter::VisitConvertVectorExpr(ConvertVectorExpr *Node) { … }

void StmtPrinter::VisitInitListExpr(InitListExpr* Node) { … }

void StmtPrinter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *Node) { … }

void StmtPrinter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *Node) { … }

void StmtPrinter::VisitParenListExpr(ParenListExpr* Node) { … }

void StmtPrinter::VisitDesignatedInitExpr(DesignatedInitExpr *Node) { … }

void StmtPrinter::VisitDesignatedInitUpdateExpr(
    DesignatedInitUpdateExpr *Node) { … }

void StmtPrinter::VisitNoInitExpr(NoInitExpr *Node) { … }

void StmtPrinter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *Node) { … }

void StmtPrinter::VisitVAArgExpr(VAArgExpr *Node) { … }

void StmtPrinter::VisitPseudoObjectExpr(PseudoObjectExpr *Node) { … }

void StmtPrinter::VisitAtomicExpr(AtomicExpr *Node) { … }

// C++
void StmtPrinter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *Node) { … }

void StmtPrinter::VisitCXXMemberCallExpr(CXXMemberCallExpr *Node) { … }

void StmtPrinter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *Node) { … }

void StmtPrinter::VisitCXXRewrittenBinaryOperator(
    CXXRewrittenBinaryOperator *Node) { … }

void StmtPrinter::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) { … }

void StmtPrinter::VisitCXXStaticCastExpr(CXXStaticCastExpr *Node) { … }

void StmtPrinter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *Node) { … }

void StmtPrinter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *Node) { … }

void StmtPrinter::VisitCXXConstCastExpr(CXXConstCastExpr *Node) { … }

void StmtPrinter::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *Node) { … }

void StmtPrinter::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *Node) { … }

void StmtPrinter::VisitCXXTypeidExpr(CXXTypeidExpr *Node) { … }

void StmtPrinter::VisitCXXUuidofExpr(CXXUuidofExpr *Node) { … }

void StmtPrinter::VisitMSPropertyRefExpr(MSPropertyRefExpr *Node) { … }

void StmtPrinter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *Node) { … }

void StmtPrinter::VisitUserDefinedLiteral(UserDefinedLiteral *Node) { … }

void StmtPrinter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) { … }

void StmtPrinter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *Node) { … }

void StmtPrinter::VisitCXXThisExpr(CXXThisExpr *Node) { … }

void StmtPrinter::VisitCXXThrowExpr(CXXThrowExpr *Node) { … }

void StmtPrinter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *Node) { … }

void StmtPrinter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *Node) { … }

void StmtPrinter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) { … }

void StmtPrinter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node) { … }

void StmtPrinter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *Node) { … }

void StmtPrinter::VisitLambdaExpr(LambdaExpr *Node) { … }

void StmtPrinter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *Node) { … }

void StmtPrinter::VisitCXXNewExpr(CXXNewExpr *E) { … }

void StmtPrinter::VisitCXXDeleteExpr(CXXDeleteExpr *E) { … }

void StmtPrinter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { … }

void StmtPrinter::VisitCXXConstructExpr(CXXConstructExpr *E) { … }

void StmtPrinter::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) { … }

void StmtPrinter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) { … }

void StmtPrinter::VisitExprWithCleanups(ExprWithCleanups *E) { … }

void StmtPrinter::VisitCXXUnresolvedConstructExpr(
    CXXUnresolvedConstructExpr *Node) { … }

void StmtPrinter::VisitCXXDependentScopeMemberExpr(
                                         CXXDependentScopeMemberExpr *Node) { … }

void StmtPrinter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *Node) { … }

void StmtPrinter::VisitTypeTraitExpr(TypeTraitExpr *E) { … }

void StmtPrinter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { … }

void StmtPrinter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { … }

void StmtPrinter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { … }

void StmtPrinter::VisitPackExpansionExpr(PackExpansionExpr *E) { … }

void StmtPrinter::VisitSizeOfPackExpr(SizeOfPackExpr *E) { … }

void StmtPrinter::VisitPackIndexingExpr(PackIndexingExpr *E) { … }

void StmtPrinter::VisitSubstNonTypeTemplateParmPackExpr(
                                       SubstNonTypeTemplateParmPackExpr *Node) { … }

void StmtPrinter::VisitSubstNonTypeTemplateParmExpr(
                                       SubstNonTypeTemplateParmExpr *Node) { … }

void StmtPrinter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) { … }

void StmtPrinter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *Node){ … }

void StmtPrinter::VisitCXXFoldExpr(CXXFoldExpr *E) { … }

void StmtPrinter::VisitCXXParenListInitExpr(CXXParenListInitExpr *Node) { … }

void StmtPrinter::VisitConceptSpecializationExpr(ConceptSpecializationExpr *E) { … }

void StmtPrinter::VisitRequiresExpr(RequiresExpr *E) { … }

// C++ Coroutines

void StmtPrinter::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) { … }

void StmtPrinter::VisitCoreturnStmt(CoreturnStmt *S) { … }

void StmtPrinter::VisitCoawaitExpr(CoawaitExpr *S) { … }

void StmtPrinter::VisitDependentCoawaitExpr(DependentCoawaitExpr *S) { … }

void StmtPrinter::VisitCoyieldExpr(CoyieldExpr *S) { … }

// Obj-C

void StmtPrinter::VisitObjCStringLiteral(ObjCStringLiteral *Node) { … }

void StmtPrinter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) { … }

void StmtPrinter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) { … }

void StmtPrinter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) { … }

void StmtPrinter::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) { … }

void StmtPrinter::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) { … }

void StmtPrinter::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) { … }

void StmtPrinter::VisitObjCMessageExpr(ObjCMessageExpr *Mess) { … }

void StmtPrinter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *Node) { … }

void
StmtPrinter::VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) { … }

void
StmtPrinter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { … }

void StmtPrinter::VisitBlockExpr(BlockExpr *Node) { … }

void StmtPrinter::VisitOpaqueValueExpr(OpaqueValueExpr *Node) { … }

void StmtPrinter::VisitTypoExpr(TypoExpr *Node) { … }

void StmtPrinter::VisitRecoveryExpr(RecoveryExpr *Node) { … }

void StmtPrinter::VisitAsTypeExpr(AsTypeExpr *Node) { … }

void StmtPrinter::VisitHLSLOutArgExpr(HLSLOutArgExpr *Node) { … }

//===----------------------------------------------------------------------===//
// Stmt method implementations
//===----------------------------------------------------------------------===//

void Stmt::dumpPretty(const ASTContext &Context) const { … }

void Stmt::printPretty(raw_ostream &Out, PrinterHelper *Helper,
                       const PrintingPolicy &Policy, unsigned Indentation,
                       StringRef NL, const ASTContext *Context) const { … }

void Stmt::printPrettyControlled(raw_ostream &Out, PrinterHelper *Helper,
                                 const PrintingPolicy &Policy,
                                 unsigned Indentation, StringRef NL,
                                 const ASTContext *Context) const { … }

void Stmt::printJson(raw_ostream &Out, PrinterHelper *Helper,
                     const PrintingPolicy &Policy, bool AddQuotes) const { … }

//===----------------------------------------------------------------------===//
// PrinterHelper
//===----------------------------------------------------------------------===//

// Implement virtual destructor.
PrinterHelper::~PrinterHelper() = default;
llvm/clang/lib/AST/StmtPrinter.cpp
