Codebase Browser
llvm
Go to App

llvm/clang/lib/Serialization/ASTReaderStmt.cpp 

//===- ASTReaderStmt.cpp - Stmt/Expr Deserialization ----------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// Statement/expression deserialization.  This implements the
// ASTReader::ReadStmt method.
//
//===----------------------------------------------------------------------===//

#include "clang/AST/ASTConcept.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/AttrIterator.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclAccessPair.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclGroup.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/DeclarationName.h"
#include "clang/AST/DependenceFlags.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/OperationKinds.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/AST/UnresolvedSet.h"
#include "clang/Basic/CapturedStmt.h"
#include "clang/Basic/ExpressionTraits.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/Lambda.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/OpenMPKinds.h"
#include "clang/Basic/OperatorKinds.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/Specifiers.h"
#include "clang/Basic/TypeTraits.h"
#include "clang/Lex/Token.h"
#include "clang/Serialization/ASTBitCodes.h"
#include "clang/Serialization/ASTRecordReader.h"
#include "llvm/ADT/BitmaskEnum.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Bitstream/BitstreamReader.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/ErrorHandling.h"
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <optional>
#include <string>

usingnamespaceclang;
usingnamespaceserialization;

namespace clang {

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

} // namespace clang

void ASTStmtReader::ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
                                              TemplateArgumentLoc *ArgsLocArray,
                                              unsigned NumTemplateArgs) { … }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static ConstraintSatisfaction
readConstraintSatisfaction(ASTRecordReader &Record) { … }

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

static concepts::Requirement::SubstitutionDiagnostic *
readSubstitutionDiagnostic(ASTRecordReader &Record) { … }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//===----------------------------------------------------------------------===//
// ASTReader Implementation
//===----------------------------------------------------------------------===//

Stmt *ASTReader::ReadStmt(ModuleFile &F) { … }

Expr *ASTReader::ReadExpr(ModuleFile &F) { … }

Expr *ASTReader::ReadSubExpr() { … }

// Within the bitstream, expressions are stored in Reverse Polish
// Notation, with each of the subexpressions preceding the
// expression they are stored in. Subexpressions are stored from last to first.
// To evaluate expressions, we continue reading expressions and placing them on
// the stack, with expressions having operands removing those operands from the
// stack. Evaluation terminates when we see a STMT_STOP record, and
// the single remaining expression on the stack is our result.
Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { … }