Codebase Browser
llvm
Go to App

llvm/clang/lib/Serialization/ASTWriterStmt.cpp 

//===--- ASTWriterStmt.cpp - Statement and Expression Serialization -------===//
//
// 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
//
//===----------------------------------------------------------------------===//
///
/// \file
/// Implements serialization for Statements and Expressions.
///
//===----------------------------------------------------------------------===//

#include "clang/AST/ASTConcept.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/ExprOpenMP.h"
#include "clang/AST/StmtVisitor.h"
#include "clang/Lex/Token.h"
#include "clang/Serialization/ASTReader.h"
#include "clang/Serialization/ASTRecordWriter.h"
#include "llvm/Bitstream/BitstreamWriter.h"
usingnamespaceclang;

//===----------------------------------------------------------------------===//
// Statement/expression serialization
//===----------------------------------------------------------------------===//

namespace clang {

  class ASTStmtWriter : public StmtVisitor<ASTStmtWriter, void> { … };
}

void ASTStmtWriter::AddTemplateKWAndArgsInfo(
    const ASTTemplateKWAndArgsInfo &ArgInfo, const TemplateArgumentLoc *Args) { … }

void ASTStmtWriter::VisitStmt(Stmt *S) { … }

void ASTStmtWriter::VisitNullStmt(NullStmt *S) { … }

void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) { … }

void ASTStmtWriter::VisitSwitchCase(SwitchCase *S) { … }

void ASTStmtWriter::VisitCaseStmt(CaseStmt *S) { … }

void ASTStmtWriter::VisitDefaultStmt(DefaultStmt *S) { … }

void ASTStmtWriter::VisitLabelStmt(LabelStmt *S) { … }

void ASTStmtWriter::VisitAttributedStmt(AttributedStmt *S) { … }

void ASTStmtWriter::VisitIfStmt(IfStmt *S) { … }

void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) { … }

void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) { … }

void ASTStmtWriter::VisitDoStmt(DoStmt *S) { … }

void ASTStmtWriter::VisitForStmt(ForStmt *S) { … }

void ASTStmtWriter::VisitGotoStmt(GotoStmt *S) { … }

void ASTStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) { … }

void ASTStmtWriter::VisitContinueStmt(ContinueStmt *S) { … }

void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) { … }

void ASTStmtWriter::VisitReturnStmt(ReturnStmt *S) { … }

void ASTStmtWriter::VisitDeclStmt(DeclStmt *S) { … }

void ASTStmtWriter::VisitAsmStmt(AsmStmt *S) { … }

void ASTStmtWriter::VisitGCCAsmStmt(GCCAsmStmt *S) { … }

void ASTStmtWriter::VisitMSAsmStmt(MSAsmStmt *S) { … }

void ASTStmtWriter::VisitCoroutineBodyStmt(CoroutineBodyStmt *CoroStmt) { … }

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

void ASTStmtWriter::VisitCoroutineSuspendExpr(CoroutineSuspendExpr *E) { … }

void ASTStmtWriter::VisitCoawaitExpr(CoawaitExpr *E) { … }

void ASTStmtWriter::VisitCoyieldExpr(CoyieldExpr *E) { … }

void ASTStmtWriter::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) { … }

static void
addConstraintSatisfaction(ASTRecordWriter &Record,
                          const ASTConstraintSatisfaction &Satisfaction) { … }

static void
addSubstitutionDiagnostic(
    ASTRecordWriter &Record,
    const concepts::Requirement::SubstitutionDiagnostic *D) { … }

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

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


void ASTStmtWriter::VisitCapturedStmt(CapturedStmt *S) { … }

void ASTStmtWriter::VisitExpr(Expr *E) { … }

void ASTStmtWriter::VisitConstantExpr(ConstantExpr *E) { … }

void ASTStmtWriter::VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E) { … }

void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) { … }

void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) { … }

void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) { … }

void ASTStmtWriter::VisitFixedPointLiteral(FixedPointLiteral *E) { … }

void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) { … }

void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) { … }

void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) { … }

void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) { … }

void ASTStmtWriter::VisitParenExpr(ParenExpr *E) { … }

void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) { … }

void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) { … }

void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) { … }

void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) { … }

void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { … }

void ASTStmtWriter::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E) { … }

void ASTStmtWriter::VisitArraySectionExpr(ArraySectionExpr *E) { … }

void ASTStmtWriter::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *E) { … }

void ASTStmtWriter::VisitOMPIteratorExpr(OMPIteratorExpr *E) { … }

void ASTStmtWriter::VisitCallExpr(CallExpr *E) { … }

void ASTStmtWriter::VisitRecoveryExpr(RecoveryExpr *E) { … }

void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) { … }

void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) { … }

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

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

void ASTStmtWriter::VisitCastExpr(CastExpr *E) { … }

void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) { … }

void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) { … }

void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) { … }

void
ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) { … }

void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) { … }

void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) { … }

void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) { … }

void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { … }

void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) { … }

void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) { … }

void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) { … }

void ASTStmtWriter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) { … }

void ASTStmtWriter::VisitNoInitExpr(NoInitExpr *E) { … }

void ASTStmtWriter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) { … }

void ASTStmtWriter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) { … }

void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { … }

void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) { … }

void ASTStmtWriter::VisitSourceLocExpr(SourceLocExpr *E) { … }

void ASTStmtWriter::VisitEmbedExpr(EmbedExpr *E) { … }

void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) { … }

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

void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) { … }

void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) { … }

void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { … }

void ASTStmtWriter::VisitConvertVectorExpr(ConvertVectorExpr *E) { … }

void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) { … }

void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) { … }

void ASTStmtWriter::VisitPseudoObjectExpr(PseudoObjectExpr *E) { … }

void ASTStmtWriter::VisitAtomicExpr(AtomicExpr *E) { … }

//===----------------------------------------------------------------------===//
// Objective-C Expressions and Statements.
//===----------------------------------------------------------------------===//

void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) { … }

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

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

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

void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) { … }

void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) { … }

void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) { … }

void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { … }

void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { … }

void ASTStmtWriter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) { … }

void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) { … }

void ASTStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { … }

void ASTStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { … }

void ASTStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { … }

void ASTStmtWriter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) { … }

void ASTStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { … }

void ASTStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) { … }

void ASTStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { … }

void ASTStmtWriter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) { … }

void ASTStmtWriter::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) { … }

//===----------------------------------------------------------------------===//
// C++ Expressions and Statements.
//===----------------------------------------------------------------------===//

void ASTStmtWriter::VisitCXXCatchStmt(CXXCatchStmt *S) { … }

void ASTStmtWriter::VisitCXXTryStmt(CXXTryStmt *S) { … }

void ASTStmtWriter::VisitCXXForRangeStmt(CXXForRangeStmt *S) { … }

void ASTStmtWriter::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) { … }

void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { … }

void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { … }

void ASTStmtWriter::VisitCXXRewrittenBinaryOperator(
    CXXRewrittenBinaryOperator *E) { … }

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

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

void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) { … }

void ASTStmtWriter::VisitLambdaExpr(LambdaExpr *E) { … }

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

void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { … }

void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) { … }

void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) { … }

void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) { … }

void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) { … }

void ASTStmtWriter::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) { … }

void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) { … }

void ASTStmtWriter::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) { … }

void ASTStmtWriter::VisitUserDefinedLiteral(UserDefinedLiteral *E) { … }

void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { … }

void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { … }

void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) { … }

void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) { … }

void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) { … }

void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { … }

void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) { … }

void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { … }

void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { … }

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

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

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

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

void ASTStmtWriter::VisitCXXDependentScopeMemberExpr(
    CXXDependentScopeMemberExpr *E) { … }

void
ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { … }

void
ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) { … }

void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) { … }

void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { … }

void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { … }

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

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

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

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

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

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

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

void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr(
                                              SubstNonTypeTemplateParmExpr *E) { … }

void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr(
                                          SubstNonTypeTemplateParmPackExpr *E) { … }

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

void ASTStmtWriter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { … }

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

void ASTStmtWriter::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) { … }

void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) { … }

void ASTStmtWriter::VisitTypoExpr(TypoExpr *E) { … }

//===----------------------------------------------------------------------===//
// CUDA Expressions and Statements.
//===----------------------------------------------------------------------===//

void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) { … }

//===----------------------------------------------------------------------===//
// OpenCL Expressions and Statements.
//===----------------------------------------------------------------------===//
void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) { … }

//===----------------------------------------------------------------------===//
// Microsoft Expressions and Statements.
//===----------------------------------------------------------------------===//
void ASTStmtWriter::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) { … }

void ASTStmtWriter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) { … }

void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) { … }

void ASTStmtWriter::VisitSEHExceptStmt(SEHExceptStmt *S) { … }

void ASTStmtWriter::VisitSEHFinallyStmt(SEHFinallyStmt *S) { … }

void ASTStmtWriter::VisitSEHTryStmt(SEHTryStmt *S) { … }

void ASTStmtWriter::VisitSEHLeaveStmt(SEHLeaveStmt *S) { … }

//===----------------------------------------------------------------------===//
// OpenMP Directives.
//===----------------------------------------------------------------------===//

void ASTStmtWriter::VisitOMPCanonicalLoop(OMPCanonicalLoop *S) { … }

void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) { … }

void ASTStmtWriter::VisitOMPLoopBasedDirective(OMPLoopBasedDirective *D) { … }

void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) { … }

void ASTStmtWriter::VisitOMPMetaDirective(OMPMetaDirective *D) { … }

void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) { … }

void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) { … }

void ASTStmtWriter::VisitOMPLoopTransformationDirective(
    OMPLoopTransformationDirective *D) { … }

void ASTStmtWriter::VisitOMPTileDirective(OMPTileDirective *D) { … }

void ASTStmtWriter::VisitOMPUnrollDirective(OMPUnrollDirective *D) { … }

void ASTStmtWriter::VisitOMPReverseDirective(OMPReverseDirective *D) { … }

void ASTStmtWriter::VisitOMPInterchangeDirective(OMPInterchangeDirective *D) { … }

void ASTStmtWriter::VisitOMPForDirective(OMPForDirective *D) { … }

void ASTStmtWriter::VisitOMPForSimdDirective(OMPForSimdDirective *D) { … }

void ASTStmtWriter::VisitOMPSectionsDirective(OMPSectionsDirective *D) { … }

void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) { … }

void ASTStmtWriter::VisitOMPScopeDirective(OMPScopeDirective *D) { … }

void ASTStmtWriter::VisitOMPSingleDirective(OMPSingleDirective *D) { … }

void ASTStmtWriter::VisitOMPMasterDirective(OMPMasterDirective *D) { … }

void ASTStmtWriter::VisitOMPCriticalDirective(OMPCriticalDirective *D) { … }

void ASTStmtWriter::VisitOMPParallelForDirective(OMPParallelForDirective *D) { … }

void ASTStmtWriter::VisitOMPParallelForSimdDirective(
    OMPParallelForSimdDirective *D) { … }

void ASTStmtWriter::VisitOMPParallelMasterDirective(
    OMPParallelMasterDirective *D) { … }

void ASTStmtWriter::VisitOMPParallelMaskedDirective(
    OMPParallelMaskedDirective *D) { … }

void ASTStmtWriter::VisitOMPParallelSectionsDirective(
    OMPParallelSectionsDirective *D) { … }

void ASTStmtWriter::VisitOMPTaskDirective(OMPTaskDirective *D) { … }

void ASTStmtWriter::VisitOMPAtomicDirective(OMPAtomicDirective *D) { … }

void ASTStmtWriter::VisitOMPTargetDirective(OMPTargetDirective *D) { … }

void ASTStmtWriter::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) { … }

void ASTStmtWriter::VisitOMPTargetEnterDataDirective(
    OMPTargetEnterDataDirective *D) { … }

void ASTStmtWriter::VisitOMPTargetExitDataDirective(
    OMPTargetExitDataDirective *D) { … }

void ASTStmtWriter::VisitOMPTargetParallelDirective(
    OMPTargetParallelDirective *D) { … }

void ASTStmtWriter::VisitOMPTargetParallelForDirective(
    OMPTargetParallelForDirective *D) { … }

void ASTStmtWriter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) { … }

void ASTStmtWriter::VisitOMPBarrierDirective(OMPBarrierDirective *D) { … }

void ASTStmtWriter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) { … }

void ASTStmtWriter::VisitOMPAssumeDirective(OMPAssumeDirective *D) { … }

void ASTStmtWriter::VisitOMPErrorDirective(OMPErrorDirective *D) { … }

void ASTStmtWriter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) { … }

void ASTStmtWriter::VisitOMPFlushDirective(OMPFlushDirective *D) { … }

void ASTStmtWriter::VisitOMPDepobjDirective(OMPDepobjDirective *D) { … }

void ASTStmtWriter::VisitOMPScanDirective(OMPScanDirective *D) { … }

void ASTStmtWriter::VisitOMPOrderedDirective(OMPOrderedDirective *D) { … }

void ASTStmtWriter::VisitOMPTeamsDirective(OMPTeamsDirective *D) { … }

void ASTStmtWriter::VisitOMPCancellationPointDirective(
    OMPCancellationPointDirective *D) { … }

void ASTStmtWriter::VisitOMPCancelDirective(OMPCancelDirective *D) { … }

void ASTStmtWriter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) { … }

void ASTStmtWriter::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) { … }

void ASTStmtWriter::VisitOMPMasterTaskLoopDirective(
    OMPMasterTaskLoopDirective *D) { … }

void ASTStmtWriter::VisitOMPMaskedTaskLoopDirective(
    OMPMaskedTaskLoopDirective *D) { … }

void ASTStmtWriter::VisitOMPMasterTaskLoopSimdDirective(
    OMPMasterTaskLoopSimdDirective *D) { … }

void ASTStmtWriter::VisitOMPMaskedTaskLoopSimdDirective(
    OMPMaskedTaskLoopSimdDirective *D) { … }

void ASTStmtWriter::VisitOMPParallelMasterTaskLoopDirective(
    OMPParallelMasterTaskLoopDirective *D) { … }

void ASTStmtWriter::VisitOMPParallelMaskedTaskLoopDirective(
    OMPParallelMaskedTaskLoopDirective *D) { … }

void ASTStmtWriter::VisitOMPParallelMasterTaskLoopSimdDirective(
    OMPParallelMasterTaskLoopSimdDirective *D) { … }

void ASTStmtWriter::VisitOMPParallelMaskedTaskLoopSimdDirective(
    OMPParallelMaskedTaskLoopSimdDirective *D) { … }

void ASTStmtWriter::VisitOMPDistributeDirective(OMPDistributeDirective *D) { … }

void ASTStmtWriter::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) { … }

void ASTStmtWriter::VisitOMPDistributeParallelForDirective(
    OMPDistributeParallelForDirective *D) { … }

void ASTStmtWriter::VisitOMPDistributeParallelForSimdDirective(
    OMPDistributeParallelForSimdDirective *D) { … }

void ASTStmtWriter::VisitOMPDistributeSimdDirective(
    OMPDistributeSimdDirective *D) { … }

void ASTStmtWriter::VisitOMPTargetParallelForSimdDirective(
    OMPTargetParallelForSimdDirective *D) { … }

void ASTStmtWriter::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) { … }

void ASTStmtWriter::VisitOMPTeamsDistributeDirective(
    OMPTeamsDistributeDirective *D) { … }

void ASTStmtWriter::VisitOMPTeamsDistributeSimdDirective(
    OMPTeamsDistributeSimdDirective *D) { … }

void ASTStmtWriter::VisitOMPTeamsDistributeParallelForSimdDirective(
    OMPTeamsDistributeParallelForSimdDirective *D) { … }

void ASTStmtWriter::VisitOMPTeamsDistributeParallelForDirective(
    OMPTeamsDistributeParallelForDirective *D) { … }

void ASTStmtWriter::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) { … }

void ASTStmtWriter::VisitOMPTargetTeamsDistributeDirective(
    OMPTargetTeamsDistributeDirective *D) { … }

void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForDirective(
    OMPTargetTeamsDistributeParallelForDirective *D) { … }

void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
    OMPTargetTeamsDistributeParallelForSimdDirective *D) { … }

void ASTStmtWriter::VisitOMPTargetTeamsDistributeSimdDirective(
    OMPTargetTeamsDistributeSimdDirective *D) { … }

void ASTStmtWriter::VisitOMPInteropDirective(OMPInteropDirective *D) { … }

void ASTStmtWriter::VisitOMPDispatchDirective(OMPDispatchDirective *D) { … }

void ASTStmtWriter::VisitOMPMaskedDirective(OMPMaskedDirective *D) { … }

void ASTStmtWriter::VisitOMPGenericLoopDirective(OMPGenericLoopDirective *D) { … }

void ASTStmtWriter::VisitOMPTeamsGenericLoopDirective(
    OMPTeamsGenericLoopDirective *D) { … }

void ASTStmtWriter::VisitOMPTargetTeamsGenericLoopDirective(
    OMPTargetTeamsGenericLoopDirective *D) { … }

void ASTStmtWriter::VisitOMPParallelGenericLoopDirective(
    OMPParallelGenericLoopDirective *D) { … }

void ASTStmtWriter::VisitOMPTargetParallelGenericLoopDirective(
    OMPTargetParallelGenericLoopDirective *D) { … }

//===----------------------------------------------------------------------===//
// OpenACC Constructs/Directives.
//===----------------------------------------------------------------------===//
void ASTStmtWriter::VisitOpenACCConstructStmt(OpenACCConstructStmt *S) { … }

void ASTStmtWriter::VisitOpenACCAssociatedStmtConstruct(
    OpenACCAssociatedStmtConstruct *S) { … }

void ASTStmtWriter::VisitOpenACCComputeConstruct(OpenACCComputeConstruct *S) { … }

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

//===----------------------------------------------------------------------===//
// HLSL Constructs/Directives.
//===----------------------------------------------------------------------===//

void ASTStmtWriter::VisitHLSLOutArgExpr(HLSLOutArgExpr *S) { … }

//===----------------------------------------------------------------------===//
// ASTWriter Implementation
//===----------------------------------------------------------------------===//

unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) { … }

unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) { … }

void ASTWriter::ClearSwitchCaseIDs() { … }

/// Write the given substatement or subexpression to the
/// bitstream.
void ASTWriter::WriteSubStmt(Stmt *S) { … }

/// Flush all of the statements that have been added to the
/// queue via AddStmt().
void ASTRecordWriter::FlushStmts() { … }

void ASTRecordWriter::FlushSubStmts() { … }