The result of preprocessing RecursiveASTVisitor.h using clang -E.

RecursiveASTVisitor.h

namespace clang {
namespace detail {
template <typename T, typename U>
struct has_same_member_pointer_type : std::false_type {};
template <typename T, typename U, typename R, typename... P>
struct has_same_member_pointer_type<R (T::*)(P...), R (U::*)(P...)>
    : std::true_type {};
template <bool has_same_type> struct is_same_method_impl {
  template <typename FirstMethodPtrTy, typename SecondMethodPtrTy>
  static bool isSameMethod(FirstMethodPtrTy FirstMethodPtr,
                           SecondMethodPtrTy SecondMethodPtr) {
    return false;
  }
};
template <> struct is_same_method_impl<true> {
  template <typename FirstMethodPtrTy, typename SecondMethodPtrTy>
  static bool isSameMethod(FirstMethodPtrTy FirstMethodPtr,
                           SecondMethodPtrTy SecondMethodPtr) {
    return FirstMethodPtr == SecondMethodPtr;
  }
};
template <typename FirstMethodPtrTy, typename SecondMethodPtrTy>
bool isSameMethod(FirstMethodPtrTy FirstMethodPtr,
                  SecondMethodPtrTy SecondMethodPtr) {
  return is_same_method_impl<has_same_member_pointer_type<
      FirstMethodPtrTy,
      SecondMethodPtrTy>::value>::isSameMethod(FirstMethodPtr, SecondMethodPtr);
}
}
template <typename Derived> class RecursiveASTVisitor {
public:
  typedef SmallVectorImpl<llvm::PointerIntPair<Stmt *, 1, bool>>
    DataRecursionQueue;
  Derived &getDerived() { return *static_cast<Derived *>(this); }
  bool shouldVisitTemplateInstantiations() const { return false; }
  bool shouldWalkTypesOfTypeLocs() const { return true; }
  bool shouldVisitImplicitCode() const { return false; }
  bool shouldVisitLambdaBody() const { return true; }
  bool shouldTraversePostOrder() const { return false; }
  bool TraverseAST(ASTContext &AST) {
    return getDerived().TraverseDecl(AST.getTranslationUnitDecl());
  }
  bool TraverseStmt(Stmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
  bool dataTraverseStmtPre(Stmt *S) { return true; }
  bool dataTraverseStmtPost(Stmt *S) { return true; }
  bool TraverseType(QualType T);
  bool TraverseTypeLoc(TypeLoc TL);
  bool TraverseAttr(Attr *At);
  bool TraverseDecl(Decl *D);
  bool TraverseNestedNameSpecifier(NestedNameSpecifier *NNS);
  bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS);
  bool TraverseDeclarationNameInfo(DeclarationNameInfo NameInfo);
  bool TraverseTemplateName(TemplateName Template);
  bool TraverseTemplateArgument(const TemplateArgument &Arg);
  bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc);
  bool TraverseTemplateArguments(const TemplateArgument *Args,
                                 unsigned NumArgs);
  bool TraverseCXXBaseSpecifier(const CXXBaseSpecifier &Base);
  bool TraverseConstructorInitializer(CXXCtorInitializer *Init);
  bool TraverseLambdaCapture(LambdaExpr *LE, const LambdaCapture *C,
                             Expr *Init);
  bool TraverseSynOrSemInitListExpr(InitListExpr *S,
                                    DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
  bool TraverseConceptReference(const ConceptReference &C);
  bool VisitAttr(Attr *A) { return true; }
  bool TraverseAArch64VectorPcsAttr(AArch64VectorPcsAttr *A);
  bool VisitAArch64VectorPcsAttr(AArch64VectorPcsAttr *A) {
    return true;
  }
  bool TraverseAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A);
  bool VisitAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A) {
    return true;
  }
  bool TraverseAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A);
  bool VisitAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A) {
    return true;
  }
  bool TraverseAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A);
  bool VisitAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A) {
    return true;
  }
  bool TraverseAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A);
  bool VisitAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A) {
    return true;
  }
  bool TraverseARMInterruptAttr(ARMInterruptAttr *A);
  bool VisitARMInterruptAttr(ARMInterruptAttr *A) {
    return true;
  }
  bool TraverseAVRInterruptAttr(AVRInterruptAttr *A);
  bool VisitAVRInterruptAttr(AVRInterruptAttr *A) {
    return true;
  }
  bool TraverseAVRSignalAttr(AVRSignalAttr *A);
  bool VisitAVRSignalAttr(AVRSignalAttr *A) {
    return true;
  }
  bool TraverseAbiTagAttr(AbiTagAttr *A);
  bool VisitAbiTagAttr(AbiTagAttr *A) {
    return true;
  }
  bool TraverseAcquireCapabilityAttr(AcquireCapabilityAttr *A);
  bool VisitAcquireCapabilityAttr(AcquireCapabilityAttr *A) {
    return true;
  }
  bool TraverseAcquireHandleAttr(AcquireHandleAttr *A);
  bool VisitAcquireHandleAttr(AcquireHandleAttr *A) {
    return true;
  }
  bool TraverseAcquiredAfterAttr(AcquiredAfterAttr *A);
  bool VisitAcquiredAfterAttr(AcquiredAfterAttr *A) {
    return true;
  }
  bool TraverseAcquiredBeforeAttr(AcquiredBeforeAttr *A);
  bool VisitAcquiredBeforeAttr(AcquiredBeforeAttr *A) {
    return true;
  }
  bool TraverseAddressSpaceAttr(AddressSpaceAttr *A);
  bool VisitAddressSpaceAttr(AddressSpaceAttr *A) {
    return true;
  }
  bool TraverseAliasAttr(AliasAttr *A);
  bool VisitAliasAttr(AliasAttr *A) {
    return true;
  }
  bool TraverseAlignMac68kAttr(AlignMac68kAttr *A);
  bool VisitAlignMac68kAttr(AlignMac68kAttr *A) {
    return true;
  }
  bool TraverseAlignNaturalAttr(AlignNaturalAttr *A);
  bool VisitAlignNaturalAttr(AlignNaturalAttr *A) {
    return true;
  }
  bool TraverseAlignValueAttr(AlignValueAttr *A);
  bool VisitAlignValueAttr(AlignValueAttr *A) {
    return true;
  }
  bool TraverseAlignedAttr(AlignedAttr *A);
  bool VisitAlignedAttr(AlignedAttr *A) {
    return true;
  }
  bool TraverseAllocAlignAttr(AllocAlignAttr *A);
  bool VisitAllocAlignAttr(AllocAlignAttr *A) {
    return true;
  }
  bool TraverseAllocSizeAttr(AllocSizeAttr *A);
  bool VisitAllocSizeAttr(AllocSizeAttr *A) {
    return true;
  }
  bool TraverseAlwaysDestroyAttr(AlwaysDestroyAttr *A);
  bool VisitAlwaysDestroyAttr(AlwaysDestroyAttr *A) {
    return true;
  }
  bool TraverseAlwaysInlineAttr(AlwaysInlineAttr *A);
  bool VisitAlwaysInlineAttr(AlwaysInlineAttr *A) {
    return true;
  }
  bool TraverseAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A);
  bool VisitAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A) {
    return true;
  }
  bool TraverseAnnotateAttr(AnnotateAttr *A);
  bool VisitAnnotateAttr(AnnotateAttr *A) {
    return true;
  }
  bool TraverseAnyX86InterruptAttr(AnyX86InterruptAttr *A);
  bool VisitAnyX86InterruptAttr(AnyX86InterruptAttr *A) {
    return true;
  }
  bool TraverseAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A);
  bool VisitAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A) {
    return true;
  }
  bool TraverseAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A);
  bool VisitAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A) {
    return true;
  }
  bool TraverseArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A);
  bool VisitArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A) {
    return true;
  }
  bool TraverseArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A);
  bool VisitArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A) {
    return true;
  }
  bool TraverseArmBuiltinAliasAttr(ArmBuiltinAliasAttr *A);
  bool VisitArmBuiltinAliasAttr(ArmBuiltinAliasAttr *A) {
    return true;
  }
  bool TraverseArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A);
  bool VisitArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A) {
    return true;
  }
  bool TraverseArtificialAttr(ArtificialAttr *A);
  bool VisitArtificialAttr(ArtificialAttr *A) {
    return true;
  }
  bool TraverseAsmLabelAttr(AsmLabelAttr *A);
  bool VisitAsmLabelAttr(AsmLabelAttr *A) {
    return true;
  }
  bool TraverseAssertCapabilityAttr(AssertCapabilityAttr *A);
  bool VisitAssertCapabilityAttr(AssertCapabilityAttr *A) {
    return true;
  }
  bool TraverseAssertExclusiveLockAttr(AssertExclusiveLockAttr *A);
  bool VisitAssertExclusiveLockAttr(AssertExclusiveLockAttr *A) {
    return true;
  }
  bool TraverseAssertSharedLockAttr(AssertSharedLockAttr *A);
  bool VisitAssertSharedLockAttr(AssertSharedLockAttr *A) {
    return true;
  }
  bool TraverseAssumeAlignedAttr(AssumeAlignedAttr *A);
  bool VisitAssumeAlignedAttr(AssumeAlignedAttr *A) {
    return true;
  }
  bool TraverseAssumptionAttr(AssumptionAttr *A);
  bool VisitAssumptionAttr(AssumptionAttr *A) {
    return true;
  }
  bool TraverseAvailabilityAttr(AvailabilityAttr *A);
  bool VisitAvailabilityAttr(AvailabilityAttr *A) {
    return true;
  }
  bool TraverseBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A);
  bool VisitBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A) {
    return true;
  }
  bool TraverseBlocksAttr(BlocksAttr *A);
  bool VisitBlocksAttr(BlocksAttr *A) {
    return true;
  }
  bool TraverseBuiltinAttr(BuiltinAttr *A);
  bool VisitBuiltinAttr(BuiltinAttr *A) {
    return true;
  }
  bool TraverseBuiltinAliasAttr(BuiltinAliasAttr *A);
  bool VisitBuiltinAliasAttr(BuiltinAliasAttr *A) {
    return true;
  }
  bool TraverseC11NoReturnAttr(C11NoReturnAttr *A);
  bool VisitC11NoReturnAttr(C11NoReturnAttr *A) {
    return true;
  }
  bool TraverseCDeclAttr(CDeclAttr *A);
  bool VisitCDeclAttr(CDeclAttr *A) {
    return true;
  }
  bool TraverseCFAuditedTransferAttr(CFAuditedTransferAttr *A);
  bool VisitCFAuditedTransferAttr(CFAuditedTransferAttr *A) {
    return true;
  }
  bool TraverseCFConsumedAttr(CFConsumedAttr *A);
  bool VisitCFConsumedAttr(CFConsumedAttr *A) {
    return true;
  }
  bool TraverseCFGuardAttr(CFGuardAttr *A);
  bool VisitCFGuardAttr(CFGuardAttr *A) {
    return true;
  }
  bool TraverseCFICanonicalJumpTableAttr(CFICanonicalJumpTableAttr *A);
  bool VisitCFICanonicalJumpTableAttr(CFICanonicalJumpTableAttr *A) {
    return true;
  }
  bool TraverseCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A);
  bool VisitCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A) {
    return true;
  }
  bool TraverseCFReturnsRetainedAttr(CFReturnsRetainedAttr *A);
  bool VisitCFReturnsRetainedAttr(CFReturnsRetainedAttr *A) {
    return true;
  }
  bool TraverseCFUnknownTransferAttr(CFUnknownTransferAttr *A);
  bool VisitCFUnknownTransferAttr(CFUnknownTransferAttr *A) {
    return true;
  }
  bool TraverseCPUDispatchAttr(CPUDispatchAttr *A);
  bool VisitCPUDispatchAttr(CPUDispatchAttr *A) {
    return true;
  }
  bool TraverseCPUSpecificAttr(CPUSpecificAttr *A);
  bool VisitCPUSpecificAttr(CPUSpecificAttr *A) {
    return true;
  }
  bool TraverseCUDAConstantAttr(CUDAConstantAttr *A);
  bool VisitCUDAConstantAttr(CUDAConstantAttr *A) {
    return true;
  }
  bool TraverseCUDADeviceAttr(CUDADeviceAttr *A);
  bool VisitCUDADeviceAttr(CUDADeviceAttr *A) {
    return true;
  }
  bool TraverseCUDADeviceBuiltinSurfaceTypeAttr(CUDADeviceBuiltinSurfaceTypeAttr *A);
  bool VisitCUDADeviceBuiltinSurfaceTypeAttr(CUDADeviceBuiltinSurfaceTypeAttr *A) {
    return true;
  }
  bool TraverseCUDADeviceBuiltinTextureTypeAttr(CUDADeviceBuiltinTextureTypeAttr *A);
  bool VisitCUDADeviceBuiltinTextureTypeAttr(CUDADeviceBuiltinTextureTypeAttr *A) {
    return true;
  }
  bool TraverseCUDAGlobalAttr(CUDAGlobalAttr *A);
  bool VisitCUDAGlobalAttr(CUDAGlobalAttr *A) {
    return true;
  }
  bool TraverseCUDAHostAttr(CUDAHostAttr *A);
  bool VisitCUDAHostAttr(CUDAHostAttr *A) {
    return true;
  }
  bool TraverseCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A);
  bool VisitCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A) {
    return true;
  }
  bool TraverseCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A);
  bool VisitCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A) {
    return true;
  }
  bool TraverseCUDASharedAttr(CUDASharedAttr *A);
  bool VisitCUDASharedAttr(CUDASharedAttr *A) {
    return true;
  }
  bool TraverseCXX11NoReturnAttr(CXX11NoReturnAttr *A);
  bool VisitCXX11NoReturnAttr(CXX11NoReturnAttr *A) {
    return true;
  }
  bool TraverseCallableWhenAttr(CallableWhenAttr *A);
  bool VisitCallableWhenAttr(CallableWhenAttr *A) {
    return true;
  }
  bool TraverseCallbackAttr(CallbackAttr *A);
  bool VisitCallbackAttr(CallbackAttr *A) {
    return true;
  }
  bool TraverseCalledOnceAttr(CalledOnceAttr *A);
  bool VisitCalledOnceAttr(CalledOnceAttr *A) {
    return true;
  }
  bool TraverseCapabilityAttr(CapabilityAttr *A);
  bool VisitCapabilityAttr(CapabilityAttr *A) {
    return true;
  }
  bool TraverseCapturedRecordAttr(CapturedRecordAttr *A);
  bool VisitCapturedRecordAttr(CapturedRecordAttr *A) {
    return true;
  }
  bool TraverseCarriesDependencyAttr(CarriesDependencyAttr *A);
  bool VisitCarriesDependencyAttr(CarriesDependencyAttr *A) {
    return true;
  }
  bool TraverseCleanupAttr(CleanupAttr *A);
  bool VisitCleanupAttr(CleanupAttr *A) {
    return true;
  }
  bool TraverseCmseNSCallAttr(CmseNSCallAttr *A);
  bool VisitCmseNSCallAttr(CmseNSCallAttr *A) {
    return true;
  }
  bool TraverseCmseNSEntryAttr(CmseNSEntryAttr *A);
  bool VisitCmseNSEntryAttr(CmseNSEntryAttr *A) {
    return true;
  }
  bool TraverseCodeSegAttr(CodeSegAttr *A);
  bool VisitCodeSegAttr(CodeSegAttr *A) {
    return true;
  }
  bool TraverseColdAttr(ColdAttr *A);
  bool VisitColdAttr(ColdAttr *A) {
    return true;
  }
  bool TraverseCommonAttr(CommonAttr *A);
  bool VisitCommonAttr(CommonAttr *A) {
    return true;
  }
  bool TraverseConstAttr(ConstAttr *A);
  bool VisitConstAttr(ConstAttr *A) {
    return true;
  }
  bool TraverseConstInitAttr(ConstInitAttr *A);
  bool VisitConstInitAttr(ConstInitAttr *A) {
    return true;
  }
  bool TraverseConstructorAttr(ConstructorAttr *A);
  bool VisitConstructorAttr(ConstructorAttr *A) {
    return true;
  }
  bool TraverseConsumableAttr(ConsumableAttr *A);
  bool VisitConsumableAttr(ConsumableAttr *A) {
    return true;
  }
  bool TraverseConsumableAutoCastAttr(ConsumableAutoCastAttr *A);
  bool VisitConsumableAutoCastAttr(ConsumableAutoCastAttr *A) {
    return true;
  }
  bool TraverseConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A);
  bool VisitConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A) {
    return true;
  }
  bool TraverseConvergentAttr(ConvergentAttr *A);
  bool VisitConvergentAttr(ConvergentAttr *A) {
    return true;
  }
  bool TraverseDLLExportAttr(DLLExportAttr *A);
  bool VisitDLLExportAttr(DLLExportAttr *A) {
    return true;
  }
  bool TraverseDLLExportStaticLocalAttr(DLLExportStaticLocalAttr *A);
  bool VisitDLLExportStaticLocalAttr(DLLExportStaticLocalAttr *A) {
    return true;
  }
  bool TraverseDLLImportAttr(DLLImportAttr *A);
  bool VisitDLLImportAttr(DLLImportAttr *A) {
    return true;
  }
  bool TraverseDLLImportStaticLocalAttr(DLLImportStaticLocalAttr *A);
  bool VisitDLLImportStaticLocalAttr(DLLImportStaticLocalAttr *A) {
    return true;
  }
  bool TraverseDeprecatedAttr(DeprecatedAttr *A);
  bool VisitDeprecatedAttr(DeprecatedAttr *A) {
    return true;
  }
  bool TraverseDestructorAttr(DestructorAttr *A);
  bool VisitDestructorAttr(DestructorAttr *A) {
    return true;
  }
  bool TraverseDiagnoseIfAttr(DiagnoseIfAttr *A);
  bool VisitDiagnoseIfAttr(DiagnoseIfAttr *A) {
    return true;
  }
  bool TraverseDisableTailCallsAttr(DisableTailCallsAttr *A);
  bool VisitDisableTailCallsAttr(DisableTailCallsAttr *A) {
    return true;
  }
  bool TraverseEmptyBasesAttr(EmptyBasesAttr *A);
  bool VisitEmptyBasesAttr(EmptyBasesAttr *A) {
    return true;
  }
  bool TraverseEnableIfAttr(EnableIfAttr *A);
  bool VisitEnableIfAttr(EnableIfAttr *A) {
    return true;
  }
  bool TraverseEnforceTCBAttr(EnforceTCBAttr *A);
  bool VisitEnforceTCBAttr(EnforceTCBAttr *A) {
    return true;
  }
  bool TraverseEnforceTCBLeafAttr(EnforceTCBLeafAttr *A);
  bool VisitEnforceTCBLeafAttr(EnforceTCBLeafAttr *A) {
    return true;
  }
  bool TraverseEnumExtensibilityAttr(EnumExtensibilityAttr *A);
  bool VisitEnumExtensibilityAttr(EnumExtensibilityAttr *A) {
    return true;
  }
  bool TraverseExcludeFromExplicitInstantiationAttr(ExcludeFromExplicitInstantiationAttr *A);
  bool VisitExcludeFromExplicitInstantiationAttr(ExcludeFromExplicitInstantiationAttr *A) {
    return true;
  }
  bool TraverseExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A);
  bool VisitExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A) {
    return true;
  }
  bool TraverseExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A);
  bool VisitExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A) {
    return true;
  }
  bool TraverseFallThroughAttr(FallThroughAttr *A);
  bool VisitFallThroughAttr(FallThroughAttr *A) {
    return true;
  }
  bool TraverseFastCallAttr(FastCallAttr *A);
  bool VisitFastCallAttr(FastCallAttr *A) {
    return true;
  }
  bool TraverseFinalAttr(FinalAttr *A);
  bool VisitFinalAttr(FinalAttr *A) {
    return true;
  }
  bool TraverseFlagEnumAttr(FlagEnumAttr *A);
  bool VisitFlagEnumAttr(FlagEnumAttr *A) {
    return true;
  }
  bool TraverseFlattenAttr(FlattenAttr *A);
  bool VisitFlattenAttr(FlattenAttr *A) {
    return true;
  }
  bool TraverseFormatAttr(FormatAttr *A);
  bool VisitFormatAttr(FormatAttr *A) {
    return true;
  }
  bool TraverseFormatArgAttr(FormatArgAttr *A);
  bool VisitFormatArgAttr(FormatArgAttr *A) {
    return true;
  }
  bool TraverseGNUInlineAttr(GNUInlineAttr *A);
  bool VisitGNUInlineAttr(GNUInlineAttr *A) {
    return true;
  }
  bool TraverseGuardedByAttr(GuardedByAttr *A);
  bool VisitGuardedByAttr(GuardedByAttr *A) {
    return true;
  }
  bool TraverseGuardedVarAttr(GuardedVarAttr *A);
  bool VisitGuardedVarAttr(GuardedVarAttr *A) {
    return true;
  }
  bool TraverseHIPManagedAttr(HIPManagedAttr *A);
  bool VisitHIPManagedAttr(HIPManagedAttr *A) {
    return true;
  }
  bool TraverseHotAttr(HotAttr *A);
  bool VisitHotAttr(HotAttr *A) {
    return true;
  }
  bool TraverseIBActionAttr(IBActionAttr *A);
  bool VisitIBActionAttr(IBActionAttr *A) {
    return true;
  }
  bool TraverseIBOutletAttr(IBOutletAttr *A);
  bool VisitIBOutletAttr(IBOutletAttr *A) {
    return true;
  }
  bool TraverseIBOutletCollectionAttr(IBOutletCollectionAttr *A);
  bool VisitIBOutletCollectionAttr(IBOutletCollectionAttr *A) {
    return true;
  }
  bool TraverseIFuncAttr(IFuncAttr *A);
  bool VisitIFuncAttr(IFuncAttr *A) {
    return true;
  }
  bool TraverseInitPriorityAttr(InitPriorityAttr *A);
  bool VisitInitPriorityAttr(InitPriorityAttr *A) {
    return true;
  }
  bool TraverseInitSegAttr(InitSegAttr *A);
  bool VisitInitSegAttr(InitSegAttr *A) {
    return true;
  }
  bool TraverseIntelOclBiccAttr(IntelOclBiccAttr *A);
  bool VisitIntelOclBiccAttr(IntelOclBiccAttr *A) {
    return true;
  }
  bool TraverseInternalLinkageAttr(InternalLinkageAttr *A);
  bool VisitInternalLinkageAttr(InternalLinkageAttr *A) {
    return true;
  }
  bool TraverseLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A);
  bool VisitLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A) {
    return true;
  }
  bool TraverseLayoutVersionAttr(LayoutVersionAttr *A);
  bool VisitLayoutVersionAttr(LayoutVersionAttr *A) {
    return true;
  }
  bool TraverseLeafAttr(LeafAttr *A);
  bool VisitLeafAttr(LeafAttr *A) {
    return true;
  }
  bool TraverseLifetimeBoundAttr(LifetimeBoundAttr *A);
  bool VisitLifetimeBoundAttr(LifetimeBoundAttr *A) {
    return true;
  }
  bool TraverseLikelyAttr(LikelyAttr *A);
  bool VisitLikelyAttr(LikelyAttr *A) {
    return true;
  }
  bool TraverseLoaderUninitializedAttr(LoaderUninitializedAttr *A);
  bool VisitLoaderUninitializedAttr(LoaderUninitializedAttr *A) {
    return true;
  }
  bool TraverseLockReturnedAttr(LockReturnedAttr *A);
  bool VisitLockReturnedAttr(LockReturnedAttr *A) {
    return true;
  }
  bool TraverseLocksExcludedAttr(LocksExcludedAttr *A);
  bool VisitLocksExcludedAttr(LocksExcludedAttr *A) {
    return true;
  }
  bool TraverseLoopHintAttr(LoopHintAttr *A);
  bool VisitLoopHintAttr(LoopHintAttr *A) {
    return true;
  }
  bool TraverseM68kInterruptAttr(M68kInterruptAttr *A);
  bool VisitM68kInterruptAttr(M68kInterruptAttr *A) {
    return true;
  }
  bool TraverseMIGServerRoutineAttr(MIGServerRoutineAttr *A);
  bool VisitMIGServerRoutineAttr(MIGServerRoutineAttr *A) {
    return true;
  }
  bool TraverseMSABIAttr(MSABIAttr *A);
  bool VisitMSABIAttr(MSABIAttr *A) {
    return true;
  }
  bool TraverseMSAllocatorAttr(MSAllocatorAttr *A);
  bool VisitMSAllocatorAttr(MSAllocatorAttr *A) {
    return true;
  }
  bool TraverseMSInheritanceAttr(MSInheritanceAttr *A);
  bool VisitMSInheritanceAttr(MSInheritanceAttr *A) {
    return true;
  }
  bool TraverseMSNoVTableAttr(MSNoVTableAttr *A);
  bool VisitMSNoVTableAttr(MSNoVTableAttr *A) {
    return true;
  }
  bool TraverseMSP430InterruptAttr(MSP430InterruptAttr *A);
  bool VisitMSP430InterruptAttr(MSP430InterruptAttr *A) {
    return true;
  }
  bool TraverseMSStructAttr(MSStructAttr *A);
  bool VisitMSStructAttr(MSStructAttr *A) {
    return true;
  }
  bool TraverseMSVtorDispAttr(MSVtorDispAttr *A);
  bool VisitMSVtorDispAttr(MSVtorDispAttr *A) {
    return true;
  }
  bool TraverseMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A);
  bool VisitMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A) {
    return true;
  }
  bool TraverseMayAliasAttr(MayAliasAttr *A);
  bool VisitMayAliasAttr(MayAliasAttr *A) {
    return true;
  }
  bool TraverseMicroMipsAttr(MicroMipsAttr *A);
  bool VisitMicroMipsAttr(MicroMipsAttr *A) {
    return true;
  }
  bool TraverseMinSizeAttr(MinSizeAttr *A);
  bool VisitMinSizeAttr(MinSizeAttr *A) {
    return true;
  }
  bool TraverseMinVectorWidthAttr(MinVectorWidthAttr *A);
  bool VisitMinVectorWidthAttr(MinVectorWidthAttr *A) {
    return true;
  }
  bool TraverseMips16Attr(Mips16Attr *A);
  bool VisitMips16Attr(Mips16Attr *A) {
    return true;
  }
  bool TraverseMipsInterruptAttr(MipsInterruptAttr *A);
  bool VisitMipsInterruptAttr(MipsInterruptAttr *A) {
    return true;
  }
  bool TraverseMipsLongCallAttr(MipsLongCallAttr *A);
  bool VisitMipsLongCallAttr(MipsLongCallAttr *A) {
    return true;
  }
  bool TraverseMipsShortCallAttr(MipsShortCallAttr *A);
  bool VisitMipsShortCallAttr(MipsShortCallAttr *A) {
    return true;
  }
  bool TraverseModeAttr(ModeAttr *A);
  bool VisitModeAttr(ModeAttr *A) {
    return true;
  }
  bool TraverseMustTailAttr(MustTailAttr *A);
  bool VisitMustTailAttr(MustTailAttr *A) {
    return true;
  }
  bool TraverseNSConsumedAttr(NSConsumedAttr *A);
  bool VisitNSConsumedAttr(NSConsumedAttr *A) {
    return true;
  }
  bool TraverseNSConsumesSelfAttr(NSConsumesSelfAttr *A);
  bool VisitNSConsumesSelfAttr(NSConsumesSelfAttr *A) {
    return true;
  }
  bool TraverseNSErrorDomainAttr(NSErrorDomainAttr *A);
  bool VisitNSErrorDomainAttr(NSErrorDomainAttr *A) {
    return true;
  }
  bool TraverseNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A);
  bool VisitNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A) {
    return true;
  }
  bool TraverseNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A);
  bool VisitNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A) {
    return true;
  }
  bool TraverseNSReturnsRetainedAttr(NSReturnsRetainedAttr *A);
  bool VisitNSReturnsRetainedAttr(NSReturnsRetainedAttr *A) {
    return true;
  }
  bool TraverseNakedAttr(NakedAttr *A);
  bool VisitNakedAttr(NakedAttr *A) {
    return true;
  }
  bool TraverseNoAliasAttr(NoAliasAttr *A);
  bool VisitNoAliasAttr(NoAliasAttr *A) {
    return true;
  }
  bool TraverseNoBuiltinAttr(NoBuiltinAttr *A);
  bool VisitNoBuiltinAttr(NoBuiltinAttr *A) {
    return true;
  }
  bool TraverseNoCommonAttr(NoCommonAttr *A);
  bool VisitNoCommonAttr(NoCommonAttr *A) {
    return true;
  }
  bool TraverseNoDebugAttr(NoDebugAttr *A);
  bool VisitNoDebugAttr(NoDebugAttr *A) {
    return true;
  }
  bool TraverseNoDerefAttr(NoDerefAttr *A);
  bool VisitNoDerefAttr(NoDerefAttr *A) {
    return true;
  }
  bool TraverseNoDestroyAttr(NoDestroyAttr *A);
  bool VisitNoDestroyAttr(NoDestroyAttr *A) {
    return true;
  }
  bool TraverseNoDuplicateAttr(NoDuplicateAttr *A);
  bool VisitNoDuplicateAttr(NoDuplicateAttr *A) {
    return true;
  }
  bool TraverseNoEscapeAttr(NoEscapeAttr *A);
  bool VisitNoEscapeAttr(NoEscapeAttr *A) {
    return true;
  }
  bool TraverseNoInlineAttr(NoInlineAttr *A);
  bool VisitNoInlineAttr(NoInlineAttr *A) {
    return true;
  }
  bool TraverseNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A);
  bool VisitNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A) {
    return true;
  }
  bool TraverseNoMergeAttr(NoMergeAttr *A);
  bool VisitNoMergeAttr(NoMergeAttr *A) {
    return true;
  }
  bool TraverseNoMicroMipsAttr(NoMicroMipsAttr *A);
  bool VisitNoMicroMipsAttr(NoMicroMipsAttr *A) {
    return true;
  }
  bool TraverseNoMips16Attr(NoMips16Attr *A);
  bool VisitNoMips16Attr(NoMips16Attr *A) {
    return true;
  }
  bool TraverseNoProfileFunctionAttr(NoProfileFunctionAttr *A);
  bool VisitNoProfileFunctionAttr(NoProfileFunctionAttr *A) {
    return true;
  }
  bool TraverseNoReturnAttr(NoReturnAttr *A);
  bool VisitNoReturnAttr(NoReturnAttr *A) {
    return true;
  }
  bool TraverseNoSanitizeAttr(NoSanitizeAttr *A);
  bool VisitNoSanitizeAttr(NoSanitizeAttr *A) {
    return true;
  }
  bool TraverseNoSpeculativeLoadHardeningAttr(NoSpeculativeLoadHardeningAttr *A);
  bool VisitNoSpeculativeLoadHardeningAttr(NoSpeculativeLoadHardeningAttr *A) {
    return true;
  }
  bool TraverseNoSplitStackAttr(NoSplitStackAttr *A);
  bool VisitNoSplitStackAttr(NoSplitStackAttr *A) {
    return true;
  }
  bool TraverseNoStackProtectorAttr(NoStackProtectorAttr *A);
  bool VisitNoStackProtectorAttr(NoStackProtectorAttr *A) {
    return true;
  }
  bool TraverseNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A);
  bool VisitNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A) {
    return true;
  }
  bool TraverseNoThrowAttr(NoThrowAttr *A);
  bool VisitNoThrowAttr(NoThrowAttr *A) {
    return true;
  }
  bool TraverseNoUniqueAddressAttr(NoUniqueAddressAttr *A);
  bool VisitNoUniqueAddressAttr(NoUniqueAddressAttr *A) {
    return true;
  }
  bool TraverseNonNullAttr(NonNullAttr *A);
  bool VisitNonNullAttr(NonNullAttr *A) {
    return true;
  }
  bool TraverseNotTailCalledAttr(NotTailCalledAttr *A);
  bool VisitNotTailCalledAttr(NotTailCalledAttr *A) {
    return true;
  }
  bool TraverseOMPAllocateDeclAttr(OMPAllocateDeclAttr *A);
  bool VisitOMPAllocateDeclAttr(OMPAllocateDeclAttr *A) {
    return true;
  }
  bool TraverseOMPCaptureKindAttr(OMPCaptureKindAttr *A);
  bool VisitOMPCaptureKindAttr(OMPCaptureKindAttr *A) {
    return true;
  }
  bool TraverseOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A);
  bool VisitOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A) {
    return true;
  }
  bool TraverseOMPDeclareSimdDeclAttr(OMPDeclareSimdDeclAttr *A);
  bool VisitOMPDeclareSimdDeclAttr(OMPDeclareSimdDeclAttr *A) {
    return true;
  }
  bool TraverseOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A);
  bool VisitOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A) {
    return true;
  }
  bool TraverseOMPDeclareVariantAttr(OMPDeclareVariantAttr *A);
  bool VisitOMPDeclareVariantAttr(OMPDeclareVariantAttr *A) {
    return true;
  }
  bool TraverseOMPReferencedVarAttr(OMPReferencedVarAttr *A);
  bool VisitOMPReferencedVarAttr(OMPReferencedVarAttr *A) {
    return true;
  }
  bool TraverseOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A);
  bool VisitOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A) {
    return true;
  }
  bool TraverseOSConsumedAttr(OSConsumedAttr *A);
  bool VisitOSConsumedAttr(OSConsumedAttr *A) {
    return true;
  }
  bool TraverseOSConsumesThisAttr(OSConsumesThisAttr *A);
  bool VisitOSConsumesThisAttr(OSConsumesThisAttr *A) {
    return true;
  }
  bool TraverseOSReturnsNotRetainedAttr(OSReturnsNotRetainedAttr *A);
  bool VisitOSReturnsNotRetainedAttr(OSReturnsNotRetainedAttr *A) {
    return true;
  }
  bool TraverseOSReturnsRetainedAttr(OSReturnsRetainedAttr *A);
  bool VisitOSReturnsRetainedAttr(OSReturnsRetainedAttr *A) {
    return true;
  }
  bool TraverseOSReturnsRetainedOnNonZeroAttr(OSReturnsRetainedOnNonZeroAttr *A);
  bool VisitOSReturnsRetainedOnNonZeroAttr(OSReturnsRetainedOnNonZeroAttr *A) {
    return true;
  }
  bool TraverseOSReturnsRetainedOnZeroAttr(OSReturnsRetainedOnZeroAttr *A);
  bool VisitOSReturnsRetainedOnZeroAttr(OSReturnsRetainedOnZeroAttr *A) {
    return true;
  }
  bool TraverseObjCBoxableAttr(ObjCBoxableAttr *A);
  bool VisitObjCBoxableAttr(ObjCBoxableAttr *A) {
    return true;
  }
  bool TraverseObjCBridgeAttr(ObjCBridgeAttr *A);
  bool VisitObjCBridgeAttr(ObjCBridgeAttr *A) {
    return true;
  }
  bool TraverseObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A);
  bool VisitObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A) {
    return true;
  }
  bool TraverseObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A);
  bool VisitObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A) {
    return true;
  }
  bool TraverseObjCClassStubAttr(ObjCClassStubAttr *A);
  bool VisitObjCClassStubAttr(ObjCClassStubAttr *A) {
    return true;
  }
  bool TraverseObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A);
  bool VisitObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A) {
    return true;
  }
  bool TraverseObjCDirectAttr(ObjCDirectAttr *A);
  bool VisitObjCDirectAttr(ObjCDirectAttr *A) {
    return true;
  }
  bool TraverseObjCDirectMembersAttr(ObjCDirectMembersAttr *A);
  bool VisitObjCDirectMembersAttr(ObjCDirectMembersAttr *A) {
    return true;
  }
  bool TraverseObjCExceptionAttr(ObjCExceptionAttr *A);
  bool VisitObjCExceptionAttr(ObjCExceptionAttr *A) {
    return true;
  }
  bool TraverseObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A);
  bool VisitObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A) {
    return true;
  }
  bool TraverseObjCExternallyRetainedAttr(ObjCExternallyRetainedAttr *A);
  bool VisitObjCExternallyRetainedAttr(ObjCExternallyRetainedAttr *A) {
    return true;
  }
  bool TraverseObjCGCAttr(ObjCGCAttr *A);
  bool VisitObjCGCAttr(ObjCGCAttr *A) {
    return true;
  }
  bool TraverseObjCIndependentClassAttr(ObjCIndependentClassAttr *A);
  bool VisitObjCIndependentClassAttr(ObjCIndependentClassAttr *A) {
    return true;
  }
  bool TraverseObjCInertUnsafeUnretainedAttr(ObjCInertUnsafeUnretainedAttr *A);
  bool VisitObjCInertUnsafeUnretainedAttr(ObjCInertUnsafeUnretainedAttr *A) {
    return true;
  }
  bool TraverseObjCKindOfAttr(ObjCKindOfAttr *A);
  bool VisitObjCKindOfAttr(ObjCKindOfAttr *A) {
    return true;
  }
  bool TraverseObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A);
  bool VisitObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A) {
    return true;
  }
  bool TraverseObjCNSObjectAttr(ObjCNSObjectAttr *A);
  bool VisitObjCNSObjectAttr(ObjCNSObjectAttr *A) {
    return true;
  }
  bool TraverseObjCNonLazyClassAttr(ObjCNonLazyClassAttr *A);
  bool VisitObjCNonLazyClassAttr(ObjCNonLazyClassAttr *A) {
    return true;
  }
  bool TraverseObjCNonRuntimeProtocolAttr(ObjCNonRuntimeProtocolAttr *A);
  bool VisitObjCNonRuntimeProtocolAttr(ObjCNonRuntimeProtocolAttr *A) {
    return true;
  }
  bool TraverseObjCOwnershipAttr(ObjCOwnershipAttr *A);
  bool VisitObjCOwnershipAttr(ObjCOwnershipAttr *A) {
    return true;
  }
  bool TraverseObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A);
  bool VisitObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A) {
    return true;
  }
  bool TraverseObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A);
  bool VisitObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A) {
    return true;
  }
  bool TraverseObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A);
  bool VisitObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A) {
    return true;
  }
  bool TraverseObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A);
  bool VisitObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A) {
    return true;
  }
  bool TraverseObjCRootClassAttr(ObjCRootClassAttr *A);
  bool VisitObjCRootClassAttr(ObjCRootClassAttr *A) {
    return true;
  }
  bool TraverseObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A);
  bool VisitObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A) {
    return true;
  }
  bool TraverseObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A);
  bool VisitObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A) {
    return true;
  }
  bool TraverseObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A);
  bool VisitObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A) {
    return true;
  }
  bool TraverseOpenCLAccessAttr(OpenCLAccessAttr *A);
  bool VisitOpenCLAccessAttr(OpenCLAccessAttr *A) {
    return true;
  }
  bool TraverseOpenCLConstantAddressSpaceAttr(OpenCLConstantAddressSpaceAttr *A);
  bool VisitOpenCLConstantAddressSpaceAttr(OpenCLConstantAddressSpaceAttr *A) {
    return true;
  }
  bool TraverseOpenCLGenericAddressSpaceAttr(OpenCLGenericAddressSpaceAttr *A);
  bool VisitOpenCLGenericAddressSpaceAttr(OpenCLGenericAddressSpaceAttr *A) {
    return true;
  }
  bool TraverseOpenCLGlobalAddressSpaceAttr(OpenCLGlobalAddressSpaceAttr *A);
  bool VisitOpenCLGlobalAddressSpaceAttr(OpenCLGlobalAddressSpaceAttr *A) {
    return true;
  }
  bool TraverseOpenCLGlobalDeviceAddressSpaceAttr(OpenCLGlobalDeviceAddressSpaceAttr *A);
  bool VisitOpenCLGlobalDeviceAddressSpaceAttr(OpenCLGlobalDeviceAddressSpaceAttr *A) {
    return true;
  }
  bool TraverseOpenCLGlobalHostAddressSpaceAttr(OpenCLGlobalHostAddressSpaceAttr *A);
  bool VisitOpenCLGlobalHostAddressSpaceAttr(OpenCLGlobalHostAddressSpaceAttr *A) {
    return true;
  }
  bool TraverseOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A);
  bool VisitOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A) {
    return true;
  }
  bool TraverseOpenCLKernelAttr(OpenCLKernelAttr *A);
  bool VisitOpenCLKernelAttr(OpenCLKernelAttr *A) {
    return true;
  }
  bool TraverseOpenCLLocalAddressSpaceAttr(OpenCLLocalAddressSpaceAttr *A);
  bool VisitOpenCLLocalAddressSpaceAttr(OpenCLLocalAddressSpaceAttr *A) {
    return true;
  }
  bool TraverseOpenCLPrivateAddressSpaceAttr(OpenCLPrivateAddressSpaceAttr *A);
  bool VisitOpenCLPrivateAddressSpaceAttr(OpenCLPrivateAddressSpaceAttr *A) {
    return true;
  }
  bool TraverseOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A);
  bool VisitOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A) {
    return true;
  }
  bool TraverseOptimizeNoneAttr(OptimizeNoneAttr *A);
  bool VisitOptimizeNoneAttr(OptimizeNoneAttr *A) {
    return true;
  }
  bool TraverseOverloadableAttr(OverloadableAttr *A);
  bool VisitOverloadableAttr(OverloadableAttr *A) {
    return true;
  }
  bool TraverseOverrideAttr(OverrideAttr *A);
  bool VisitOverrideAttr(OverrideAttr *A) {
    return true;
  }
  bool TraverseOwnerAttr(OwnerAttr *A);
  bool VisitOwnerAttr(OwnerAttr *A) {
    return true;
  }
  bool TraverseOwnershipAttr(OwnershipAttr *A);
  bool VisitOwnershipAttr(OwnershipAttr *A) {
    return true;
  }
  bool TraversePackedAttr(PackedAttr *A);
  bool VisitPackedAttr(PackedAttr *A) {
    return true;
  }
  bool TraverseParamTypestateAttr(ParamTypestateAttr *A);
  bool VisitParamTypestateAttr(ParamTypestateAttr *A) {
    return true;
  }
  bool TraversePascalAttr(PascalAttr *A);
  bool VisitPascalAttr(PascalAttr *A) {
    return true;
  }
  bool TraversePassObjectSizeAttr(PassObjectSizeAttr *A);
  bool VisitPassObjectSizeAttr(PassObjectSizeAttr *A) {
    return true;
  }
  bool TraversePatchableFunctionEntryAttr(PatchableFunctionEntryAttr *A);
  bool VisitPatchableFunctionEntryAttr(PatchableFunctionEntryAttr *A) {
    return true;
  }
  bool TraversePcsAttr(PcsAttr *A);
  bool VisitPcsAttr(PcsAttr *A) {
    return true;
  }
  bool TraversePointerAttr(PointerAttr *A);
  bool VisitPointerAttr(PointerAttr *A) {
    return true;
  }
  bool TraversePragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A);
  bool VisitPragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A) {
    return true;
  }
  bool TraversePragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A);
  bool VisitPragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A) {
    return true;
  }
  bool TraversePragmaClangRelroSectionAttr(PragmaClangRelroSectionAttr *A);
  bool VisitPragmaClangRelroSectionAttr(PragmaClangRelroSectionAttr *A) {
    return true;
  }
  bool TraversePragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A);
  bool VisitPragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A) {
    return true;
  }
  bool TraversePragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A);
  bool VisitPragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A) {
    return true;
  }
  bool TraversePreferredNameAttr(PreferredNameAttr *A);
  bool VisitPreferredNameAttr(PreferredNameAttr *A) {
    return true;
  }
  bool TraversePreserveAllAttr(PreserveAllAttr *A);
  bool VisitPreserveAllAttr(PreserveAllAttr *A) {
    return true;
  }
  bool TraversePreserveMostAttr(PreserveMostAttr *A);
  bool VisitPreserveMostAttr(PreserveMostAttr *A) {
    return true;
  }
  bool TraversePtGuardedByAttr(PtGuardedByAttr *A);
  bool VisitPtGuardedByAttr(PtGuardedByAttr *A) {
    return true;
  }
  bool TraversePtGuardedVarAttr(PtGuardedVarAttr *A);
  bool VisitPtGuardedVarAttr(PtGuardedVarAttr *A) {
    return true;
  }
  bool TraversePtr32Attr(Ptr32Attr *A);
  bool VisitPtr32Attr(Ptr32Attr *A) {
    return true;
  }
  bool TraversePtr64Attr(Ptr64Attr *A);
  bool VisitPtr64Attr(Ptr64Attr *A) {
    return true;
  }
  bool TraversePureAttr(PureAttr *A);
  bool VisitPureAttr(PureAttr *A) {
    return true;
  }
  bool TraverseRISCVInterruptAttr(RISCVInterruptAttr *A);
  bool VisitRISCVInterruptAttr(RISCVInterruptAttr *A) {
    return true;
  }
  bool TraverseRegCallAttr(RegCallAttr *A);
  bool VisitRegCallAttr(RegCallAttr *A) {
    return true;
  }
  bool TraverseReinitializesAttr(ReinitializesAttr *A);
  bool VisitReinitializesAttr(ReinitializesAttr *A) {
    return true;
  }
  bool TraverseReleaseCapabilityAttr(ReleaseCapabilityAttr *A);
  bool VisitReleaseCapabilityAttr(ReleaseCapabilityAttr *A) {
    return true;
  }
  bool TraverseReleaseHandleAttr(ReleaseHandleAttr *A);
  bool VisitReleaseHandleAttr(ReleaseHandleAttr *A) {
    return true;
  }
  bool TraverseRenderScriptKernelAttr(RenderScriptKernelAttr *A);
  bool VisitRenderScriptKernelAttr(RenderScriptKernelAttr *A) {
    return true;
  }
  bool TraverseReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A);
  bool VisitReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A) {
    return true;
  }
  bool TraverseRequiresCapabilityAttr(RequiresCapabilityAttr *A);
  bool VisitRequiresCapabilityAttr(RequiresCapabilityAttr *A) {
    return true;
  }
  bool TraverseRestrictAttr(RestrictAttr *A);
  bool VisitRestrictAttr(RestrictAttr *A) {
    return true;
  }
  bool TraverseRetainAttr(RetainAttr *A);
  bool VisitRetainAttr(RetainAttr *A) {
    return true;
  }
  bool TraverseReturnTypestateAttr(ReturnTypestateAttr *A);
  bool VisitReturnTypestateAttr(ReturnTypestateAttr *A) {
    return true;
  }
  bool TraverseReturnsNonNullAttr(ReturnsNonNullAttr *A);
  bool VisitReturnsNonNullAttr(ReturnsNonNullAttr *A) {
    return true;
  }
  bool TraverseReturnsTwiceAttr(ReturnsTwiceAttr *A);
  bool VisitReturnsTwiceAttr(ReturnsTwiceAttr *A) {
    return true;
  }
  bool TraverseSPtrAttr(SPtrAttr *A);
  bool VisitSPtrAttr(SPtrAttr *A) {
    return true;
  }
  bool TraverseSYCLKernelAttr(SYCLKernelAttr *A);
  bool VisitSYCLKernelAttr(SYCLKernelAttr *A) {
    return true;
  }
  bool TraverseScopedLockableAttr(ScopedLockableAttr *A);
  bool VisitScopedLockableAttr(ScopedLockableAttr *A) {
    return true;
  }
  bool TraverseSectionAttr(SectionAttr *A);
  bool VisitSectionAttr(SectionAttr *A) {
    return true;
  }
  bool TraverseSelectAnyAttr(SelectAnyAttr *A);
  bool VisitSelectAnyAttr(SelectAnyAttr *A) {
    return true;
  }
  bool TraverseSentinelAttr(SentinelAttr *A);
  bool VisitSentinelAttr(SentinelAttr *A) {
    return true;
  }
  bool TraverseSetTypestateAttr(SetTypestateAttr *A);
  bool VisitSetTypestateAttr(SetTypestateAttr *A) {
    return true;
  }
  bool TraverseSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A);
  bool VisitSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A) {
    return true;
  }
  bool TraverseSpeculativeLoadHardeningAttr(SpeculativeLoadHardeningAttr *A);
  bool VisitSpeculativeLoadHardeningAttr(SpeculativeLoadHardeningAttr *A) {
    return true;
  }
  bool TraverseStandaloneDebugAttr(StandaloneDebugAttr *A);
  bool VisitStandaloneDebugAttr(StandaloneDebugAttr *A) {
    return true;
  }
  bool TraverseStdCallAttr(StdCallAttr *A);
  bool VisitStdCallAttr(StdCallAttr *A) {
    return true;
  }
  bool TraverseStrictFPAttr(StrictFPAttr *A);
  bool VisitStrictFPAttr(StrictFPAttr *A) {
    return true;
  }
  bool TraverseSuppressAttr(SuppressAttr *A);
  bool VisitSuppressAttr(SuppressAttr *A) {
    return true;
  }
  bool TraverseSwiftAsyncAttr(SwiftAsyncAttr *A);
  bool VisitSwiftAsyncAttr(SwiftAsyncAttr *A) {
    return true;
  }
  bool TraverseSwiftAsyncCallAttr(SwiftAsyncCallAttr *A);
  bool VisitSwiftAsyncCallAttr(SwiftAsyncCallAttr *A) {
    return true;
  }
  bool TraverseSwiftAsyncContextAttr(SwiftAsyncContextAttr *A);
  bool VisitSwiftAsyncContextAttr(SwiftAsyncContextAttr *A) {
    return true;
  }
  bool TraverseSwiftAsyncErrorAttr(SwiftAsyncErrorAttr *A);
  bool VisitSwiftAsyncErrorAttr(SwiftAsyncErrorAttr *A) {
    return true;
  }
  bool TraverseSwiftAsyncNameAttr(SwiftAsyncNameAttr *A);
  bool VisitSwiftAsyncNameAttr(SwiftAsyncNameAttr *A) {
    return true;
  }
  bool TraverseSwiftAttrAttr(SwiftAttrAttr *A);
  bool VisitSwiftAttrAttr(SwiftAttrAttr *A) {
    return true;
  }
  bool TraverseSwiftBridgeAttr(SwiftBridgeAttr *A);
  bool VisitSwiftBridgeAttr(SwiftBridgeAttr *A) {
    return true;
  }
  bool TraverseSwiftBridgedTypedefAttr(SwiftBridgedTypedefAttr *A);
  bool VisitSwiftBridgedTypedefAttr(SwiftBridgedTypedefAttr *A) {
    return true;
  }
  bool TraverseSwiftCallAttr(SwiftCallAttr *A);
  bool VisitSwiftCallAttr(SwiftCallAttr *A) {
    return true;
  }
  bool TraverseSwiftContextAttr(SwiftContextAttr *A);
  bool VisitSwiftContextAttr(SwiftContextAttr *A) {
    return true;
  }
  bool TraverseSwiftErrorAttr(SwiftErrorAttr *A);
  bool VisitSwiftErrorAttr(SwiftErrorAttr *A) {
    return true;
  }
  bool TraverseSwiftErrorResultAttr(SwiftErrorResultAttr *A);
  bool VisitSwiftErrorResultAttr(SwiftErrorResultAttr *A) {
    return true;
  }
  bool TraverseSwiftIndirectResultAttr(SwiftIndirectResultAttr *A);
  bool VisitSwiftIndirectResultAttr(SwiftIndirectResultAttr *A) {
    return true;
  }
  bool TraverseSwiftNameAttr(SwiftNameAttr *A);
  bool VisitSwiftNameAttr(SwiftNameAttr *A) {
    return true;
  }
  bool TraverseSwiftNewTypeAttr(SwiftNewTypeAttr *A);
  bool VisitSwiftNewTypeAttr(SwiftNewTypeAttr *A) {
    return true;
  }
  bool TraverseSwiftObjCMembersAttr(SwiftObjCMembersAttr *A);
  bool VisitSwiftObjCMembersAttr(SwiftObjCMembersAttr *A) {
    return true;
  }
  bool TraverseSwiftPrivateAttr(SwiftPrivateAttr *A);
  bool VisitSwiftPrivateAttr(SwiftPrivateAttr *A) {
    return true;
  }
  bool TraverseSysVABIAttr(SysVABIAttr *A);
  bool VisitSysVABIAttr(SysVABIAttr *A) {
    return true;
  }
  bool TraverseTLSModelAttr(TLSModelAttr *A);
  bool VisitTLSModelAttr(TLSModelAttr *A) {
    return true;
  }
  bool TraverseTargetAttr(TargetAttr *A);
  bool VisitTargetAttr(TargetAttr *A) {
    return true;
  }
  bool TraverseTestTypestateAttr(TestTypestateAttr *A);
  bool VisitTestTypestateAttr(TestTypestateAttr *A) {
    return true;
  }
  bool TraverseThisCallAttr(ThisCallAttr *A);
  bool VisitThisCallAttr(ThisCallAttr *A) {
    return true;
  }
  bool TraverseThreadAttr(ThreadAttr *A);
  bool VisitThreadAttr(ThreadAttr *A) {
    return true;
  }
  bool TraverseTransparentUnionAttr(TransparentUnionAttr *A);
  bool VisitTransparentUnionAttr(TransparentUnionAttr *A) {
    return true;
  }
  bool TraverseTrivialABIAttr(TrivialABIAttr *A);
  bool VisitTrivialABIAttr(TrivialABIAttr *A) {
    return true;
  }
  bool TraverseTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A);
  bool VisitTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A) {
    return true;
  }
  bool TraverseTypeNonNullAttr(TypeNonNullAttr *A);
  bool VisitTypeNonNullAttr(TypeNonNullAttr *A) {
    return true;
  }
  bool TraverseTypeNullUnspecifiedAttr(TypeNullUnspecifiedAttr *A);
  bool VisitTypeNullUnspecifiedAttr(TypeNullUnspecifiedAttr *A) {
    return true;
  }
  bool TraverseTypeNullableAttr(TypeNullableAttr *A);
  bool VisitTypeNullableAttr(TypeNullableAttr *A) {
    return true;
  }
  bool TraverseTypeNullableResultAttr(TypeNullableResultAttr *A);
  bool VisitTypeNullableResultAttr(TypeNullableResultAttr *A) {
    return true;
  }
  bool TraverseTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A);
  bool VisitTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A) {
    return true;
  }
  bool TraverseTypeVisibilityAttr(TypeVisibilityAttr *A);
  bool VisitTypeVisibilityAttr(TypeVisibilityAttr *A) {
    return true;
  }
  bool TraverseUPtrAttr(UPtrAttr *A);
  bool VisitUPtrAttr(UPtrAttr *A) {
    return true;
  }
  bool TraverseUnavailableAttr(UnavailableAttr *A);
  bool VisitUnavailableAttr(UnavailableAttr *A) {
    return true;
  }
  bool TraverseUninitializedAttr(UninitializedAttr *A);
  bool VisitUninitializedAttr(UninitializedAttr *A) {
    return true;
  }
  bool TraverseUnlikelyAttr(UnlikelyAttr *A);
  bool VisitUnlikelyAttr(UnlikelyAttr *A) {
    return true;
  }
  bool TraverseUnusedAttr(UnusedAttr *A);
  bool VisitUnusedAttr(UnusedAttr *A) {
    return true;
  }
  bool TraverseUseHandleAttr(UseHandleAttr *A);
  bool VisitUseHandleAttr(UseHandleAttr *A) {
    return true;
  }
  bool TraverseUsedAttr(UsedAttr *A);
  bool VisitUsedAttr(UsedAttr *A) {
    return true;
  }
  bool TraverseUsingIfExistsAttr(UsingIfExistsAttr *A);
  bool VisitUsingIfExistsAttr(UsingIfExistsAttr *A) {
    return true;
  }
  bool TraverseUuidAttr(UuidAttr *A);
  bool VisitUuidAttr(UuidAttr *A) {
    return true;
  }
  bool TraverseVecReturnAttr(VecReturnAttr *A);
  bool VisitVecReturnAttr(VecReturnAttr *A) {
    return true;
  }
  bool TraverseVecTypeHintAttr(VecTypeHintAttr *A);
  bool VisitVecTypeHintAttr(VecTypeHintAttr *A) {
    return true;
  }
  bool TraverseVectorCallAttr(VectorCallAttr *A);
  bool VisitVectorCallAttr(VectorCallAttr *A) {
    return true;
  }
  bool TraverseVisibilityAttr(VisibilityAttr *A);
  bool VisitVisibilityAttr(VisibilityAttr *A) {
    return true;
  }
  bool TraverseWarnUnusedAttr(WarnUnusedAttr *A);
  bool VisitWarnUnusedAttr(WarnUnusedAttr *A) {
    return true;
  }
  bool TraverseWarnUnusedResultAttr(WarnUnusedResultAttr *A);
  bool VisitWarnUnusedResultAttr(WarnUnusedResultAttr *A) {
    return true;
  }
  bool TraverseWeakAttr(WeakAttr *A);
  bool VisitWeakAttr(WeakAttr *A) {
    return true;
  }
  bool TraverseWeakImportAttr(WeakImportAttr *A);
  bool VisitWeakImportAttr(WeakImportAttr *A) {
    return true;
  }
  bool TraverseWeakRefAttr(WeakRefAttr *A);
  bool VisitWeakRefAttr(WeakRefAttr *A) {
    return true;
  }
  bool TraverseWebAssemblyExportNameAttr(WebAssemblyExportNameAttr *A);
  bool VisitWebAssemblyExportNameAttr(WebAssemblyExportNameAttr *A) {
    return true;
  }
  bool TraverseWebAssemblyImportModuleAttr(WebAssemblyImportModuleAttr *A);
  bool VisitWebAssemblyImportModuleAttr(WebAssemblyImportModuleAttr *A) {
    return true;
  }
  bool TraverseWebAssemblyImportNameAttr(WebAssemblyImportNameAttr *A);
  bool VisitWebAssemblyImportNameAttr(WebAssemblyImportNameAttr *A) {
    return true;
  }
  bool TraverseWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A);
  bool VisitWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A) {
    return true;
  }
  bool TraverseX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A);
  bool VisitX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A) {
    return true;
  }
  bool TraverseXRayInstrumentAttr(XRayInstrumentAttr *A);
  bool VisitXRayInstrumentAttr(XRayInstrumentAttr *A) {
    return true;
  }
  bool TraverseXRayLogArgsAttr(XRayLogArgsAttr *A);
  bool VisitXRayLogArgsAttr(XRayLogArgsAttr *A) {
    return true;
  }
  Stmt::child_range getStmtChildren(Stmt *S) { return S->children(); }
private:
public:
bool TraverseGCCAsmStmt(GCCAsmStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseMSAsmStmt(MSAsmStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseBreakStmt(BreakStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXCatchStmt(CXXCatchStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXForRangeStmt(CXXForRangeStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXTryStmt(CXXTryStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCapturedStmt(CapturedStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCompoundStmt(CompoundStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseContinueStmt(ContinueStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCoreturnStmt(CoreturnStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCoroutineBodyStmt(CoroutineBodyStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseDeclStmt(DeclStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseDoStmt(DoStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseForStmt(ForStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseGotoStmt(GotoStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseIfStmt(IfStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseIndirectGotoStmt(IndirectGotoStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseMSDependentExistsStmt(MSDependentExistsStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseNullStmt(NullStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPCanonicalLoop(OMPCanonicalLoop *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPAtomicDirective(OMPAtomicDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPBarrierDirective(OMPBarrierDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPCancelDirective(OMPCancelDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPCancellationPointDirective(OMPCancellationPointDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPCriticalDirective(OMPCriticalDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPDepobjDirective(OMPDepobjDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPDispatchDirective(OMPDispatchDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPFlushDirective(OMPFlushDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPInteropDirective(OMPInteropDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPDistributeDirective(OMPDistributeDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPDistributeParallelForDirective(OMPDistributeParallelForDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPDistributeParallelForSimdDirective(OMPDistributeParallelForSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPDistributeSimdDirective(OMPDistributeSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPForDirective(OMPForDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPForSimdDirective(OMPForSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPMasterTaskLoopDirective(OMPMasterTaskLoopDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPMasterTaskLoopSimdDirective(OMPMasterTaskLoopSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPParallelForDirective(OMPParallelForDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPParallelForSimdDirective(OMPParallelForSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPParallelMasterTaskLoopDirective(OMPParallelMasterTaskLoopDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPParallelMasterTaskLoopSimdDirective(OMPParallelMasterTaskLoopSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPSimdDirective(OMPSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTargetParallelForSimdDirective(OMPTargetParallelForSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTargetSimdDirective(OMPTargetSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTargetTeamsDistributeDirective(OMPTargetTeamsDistributeDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTargetTeamsDistributeParallelForDirective(OMPTargetTeamsDistributeParallelForDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTargetTeamsDistributeParallelForSimdDirective(OMPTargetTeamsDistributeParallelForSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTargetTeamsDistributeSimdDirective(OMPTargetTeamsDistributeSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTaskLoopDirective(OMPTaskLoopDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTeamsDistributeDirective(OMPTeamsDistributeDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTeamsDistributeParallelForDirective(OMPTeamsDistributeParallelForDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTeamsDistributeParallelForSimdDirective(OMPTeamsDistributeParallelForSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTeamsDistributeSimdDirective(OMPTeamsDistributeSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTileDirective(OMPTileDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPUnrollDirective(OMPUnrollDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPMaskedDirective(OMPMaskedDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPMasterDirective(OMPMasterDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPOrderedDirective(OMPOrderedDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPParallelDirective(OMPParallelDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPParallelMasterDirective(OMPParallelMasterDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPParallelSectionsDirective(OMPParallelSectionsDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPScanDirective(OMPScanDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPSectionDirective(OMPSectionDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPSectionsDirective(OMPSectionsDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPSingleDirective(OMPSingleDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTargetDataDirective(OMPTargetDataDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTargetDirective(OMPTargetDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTargetEnterDataDirective(OMPTargetEnterDataDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTargetExitDataDirective(OMPTargetExitDataDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTargetParallelDirective(OMPTargetParallelDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTargetParallelForDirective(OMPTargetParallelForDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTargetTeamsDirective(OMPTargetTeamsDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTargetUpdateDirective(OMPTargetUpdateDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTaskDirective(OMPTaskDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTaskgroupDirective(OMPTaskgroupDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTaskwaitDirective(OMPTaskwaitDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTaskyieldDirective(OMPTaskyieldDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPTeamsDirective(OMPTeamsDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCAtCatchStmt(ObjCAtCatchStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCAtFinallyStmt(ObjCAtFinallyStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCAtThrowStmt(ObjCAtThrowStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCAtTryStmt(ObjCAtTryStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCForCollectionStmt(ObjCForCollectionStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseReturnStmt(ReturnStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseSEHExceptStmt(SEHExceptStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseSEHFinallyStmt(SEHFinallyStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseSEHLeaveStmt(SEHLeaveStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseSEHTryStmt(SEHTryStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCaseStmt(CaseStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseDefaultStmt(DefaultStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseSwitchStmt(SwitchStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseAttributedStmt(AttributedStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseBinaryConditionalOperator(BinaryConditionalOperator *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseConditionalOperator(ConditionalOperator *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseAddrLabelExpr(AddrLabelExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseArrayInitIndexExpr(ArrayInitIndexExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseArrayInitLoopExpr(ArrayInitLoopExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseArraySubscriptExpr(ArraySubscriptExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseArrayTypeTraitExpr(ArrayTypeTraitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseAsTypeExpr(AsTypeExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseAtomicExpr(AtomicExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseBinaryOperator(BinaryOperator *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCompoundAssignOperator(CompoundAssignOperator *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseBlockExpr(BlockExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXBindTemporaryExpr(CXXBindTemporaryExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXBoolLiteralExpr(CXXBoolLiteralExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXConstructExpr(CXXConstructExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXDefaultArgExpr(CXXDefaultArgExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXDefaultInitExpr(CXXDefaultInitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXDeleteExpr(CXXDeleteExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXFoldExpr(CXXFoldExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXNewExpr(CXXNewExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXNoexceptExpr(CXXNoexceptExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXScalarValueInitExpr(CXXScalarValueInitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXStdInitializerListExpr(CXXStdInitializerListExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXThisExpr(CXXThisExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXThrowExpr(CXXThrowExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXTypeidExpr(CXXTypeidExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXUuidofExpr(CXXUuidofExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCallExpr(CallExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCUDAKernelCallExpr(CUDAKernelCallExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXMemberCallExpr(CXXMemberCallExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXOperatorCallExpr(CXXOperatorCallExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseUserDefinedLiteral(UserDefinedLiteral *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseBuiltinBitCastExpr(BuiltinBitCastExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCStyleCastExpr(CStyleCastExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXFunctionalCastExpr(CXXFunctionalCastExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXConstCastExpr(CXXConstCastExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXDynamicCastExpr(CXXDynamicCastExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXReinterpretCastExpr(CXXReinterpretCastExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCXXStaticCastExpr(CXXStaticCastExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCBridgedCastExpr(ObjCBridgedCastExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseImplicitCastExpr(ImplicitCastExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCharacterLiteral(CharacterLiteral *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseChooseExpr(ChooseExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCompoundLiteralExpr(CompoundLiteralExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseConceptSpecializationExpr(ConceptSpecializationExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseConvertVectorExpr(ConvertVectorExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCoawaitExpr(CoawaitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseCoyieldExpr(CoyieldExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseDeclRefExpr(DeclRefExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseDependentCoawaitExpr(DependentCoawaitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseDesignatedInitExpr(DesignatedInitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseExpressionTraitExpr(ExpressionTraitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseExtVectorElementExpr(ExtVectorElementExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseFixedPointLiteral(FixedPointLiteral *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseFloatingLiteral(FloatingLiteral *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseConstantExpr(ConstantExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseExprWithCleanups(ExprWithCleanups *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseFunctionParmPackExpr(FunctionParmPackExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseGNUNullExpr(GNUNullExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseGenericSelectionExpr(GenericSelectionExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseImaginaryLiteral(ImaginaryLiteral *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseImplicitValueInitExpr(ImplicitValueInitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseInitListExpr(InitListExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseIntegerLiteral(IntegerLiteral *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseLambdaExpr(LambdaExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseMSPropertyRefExpr(MSPropertyRefExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseMSPropertySubscriptExpr(MSPropertySubscriptExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseMaterializeTemporaryExpr(MaterializeTemporaryExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseMatrixSubscriptExpr(MatrixSubscriptExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseMemberExpr(MemberExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseNoInitExpr(NoInitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPArraySectionExpr(OMPArraySectionExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPArrayShapingExpr(OMPArrayShapingExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOMPIteratorExpr(OMPIteratorExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCArrayLiteral(ObjCArrayLiteral *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCBoolLiteralExpr(ObjCBoolLiteralExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCBoxedExpr(ObjCBoxedExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCDictionaryLiteral(ObjCDictionaryLiteral *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCEncodeExpr(ObjCEncodeExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCIsaExpr(ObjCIsaExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCIvarRefExpr(ObjCIvarRefExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCMessageExpr(ObjCMessageExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCPropertyRefExpr(ObjCPropertyRefExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCProtocolExpr(ObjCProtocolExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCSelectorExpr(ObjCSelectorExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCStringLiteral(ObjCStringLiteral *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseObjCSubscriptRefExpr(ObjCSubscriptRefExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOffsetOfExpr(OffsetOfExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseOpaqueValueExpr(OpaqueValueExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseUnresolvedLookupExpr(UnresolvedLookupExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseUnresolvedMemberExpr(UnresolvedMemberExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraversePackExpansionExpr(PackExpansionExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseParenExpr(ParenExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseParenListExpr(ParenListExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraversePredefinedExpr(PredefinedExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraversePseudoObjectExpr(PseudoObjectExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseRecoveryExpr(RecoveryExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseRequiresExpr(RequiresExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseShuffleVectorExpr(ShuffleVectorExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseSizeOfPackExpr(SizeOfPackExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseSourceLocExpr(SourceLocExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseStmtExpr(StmtExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseStringLiteral(StringLiteral *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseSubstNonTypeTemplateParmPackExpr(SubstNonTypeTemplateParmPackExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseTypeTraitExpr(TypeTraitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseTypoExpr(TypoExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseUnaryOperator(UnaryOperator *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseVAArgExpr(VAArgExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseLabelStmt(LabelStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
bool TraverseWhileStmt(WhileStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t());
  bool WalkUpFromStmt(Stmt *S) { return getDerived().VisitStmt(S); }
  bool VisitStmt(Stmt *S) { return true; }
bool WalkUpFromAsmStmt(AsmStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitAsmStmt(S)) return false; } while (false); return true; } bool VisitAsmStmt(AsmStmt *S) { return true; }
bool WalkUpFromGCCAsmStmt(GCCAsmStmt *S) { do { if (!getDerived().WalkUpFromAsmStmt(S)) return false; } while (false); do { if (!getDerived().VisitGCCAsmStmt(S)) return false; } while (false); return true; } bool VisitGCCAsmStmt(GCCAsmStmt *S) { return true; }
bool WalkUpFromMSAsmStmt(MSAsmStmt *S) { do { if (!getDerived().WalkUpFromAsmStmt(S)) return false; } while (false); do { if (!getDerived().VisitMSAsmStmt(S)) return false; } while (false); return true; } bool VisitMSAsmStmt(MSAsmStmt *S) { return true; }
bool WalkUpFromBreakStmt(BreakStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitBreakStmt(S)) return false; } while (false); return true; } bool VisitBreakStmt(BreakStmt *S) { return true; }
bool WalkUpFromCXXCatchStmt(CXXCatchStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitCXXCatchStmt(S)) return false; } while (false); return true; } bool VisitCXXCatchStmt(CXXCatchStmt *S) { return true; }
bool WalkUpFromCXXForRangeStmt(CXXForRangeStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitCXXForRangeStmt(S)) return false; } while (false); return true; } bool VisitCXXForRangeStmt(CXXForRangeStmt *S) { return true; }
bool WalkUpFromCXXTryStmt(CXXTryStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitCXXTryStmt(S)) return false; } while (false); return true; } bool VisitCXXTryStmt(CXXTryStmt *S) { return true; }
bool WalkUpFromCapturedStmt(CapturedStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitCapturedStmt(S)) return false; } while (false); return true; } bool VisitCapturedStmt(CapturedStmt *S) { return true; }
bool WalkUpFromCompoundStmt(CompoundStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitCompoundStmt(S)) return false; } while (false); return true; } bool VisitCompoundStmt(CompoundStmt *S) { return true; }
bool WalkUpFromContinueStmt(ContinueStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitContinueStmt(S)) return false; } while (false); return true; } bool VisitContinueStmt(ContinueStmt *S) { return true; }
bool WalkUpFromCoreturnStmt(CoreturnStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitCoreturnStmt(S)) return false; } while (false); return true; } bool VisitCoreturnStmt(CoreturnStmt *S) { return true; }
bool WalkUpFromCoroutineBodyStmt(CoroutineBodyStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitCoroutineBodyStmt(S)) return false; } while (false); return true; } bool VisitCoroutineBodyStmt(CoroutineBodyStmt *S) { return true; }
bool WalkUpFromDeclStmt(DeclStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitDeclStmt(S)) return false; } while (false); return true; } bool VisitDeclStmt(DeclStmt *S) { return true; }
bool WalkUpFromDoStmt(DoStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitDoStmt(S)) return false; } while (false); return true; } bool VisitDoStmt(DoStmt *S) { return true; }
bool WalkUpFromForStmt(ForStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitForStmt(S)) return false; } while (false); return true; } bool VisitForStmt(ForStmt *S) { return true; }
bool WalkUpFromGotoStmt(GotoStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitGotoStmt(S)) return false; } while (false); return true; } bool VisitGotoStmt(GotoStmt *S) { return true; }
bool WalkUpFromIfStmt(IfStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitIfStmt(S)) return false; } while (false); return true; } bool VisitIfStmt(IfStmt *S) { return true; }
bool WalkUpFromIndirectGotoStmt(IndirectGotoStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitIndirectGotoStmt(S)) return false; } while (false); return true; } bool VisitIndirectGotoStmt(IndirectGotoStmt *S) { return true; }
bool WalkUpFromMSDependentExistsStmt(MSDependentExistsStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitMSDependentExistsStmt(S)) return false; } while (false); return true; } bool VisitMSDependentExistsStmt(MSDependentExistsStmt *S) { return true; }
bool WalkUpFromNullStmt(NullStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitNullStmt(S)) return false; } while (false); return true; } bool VisitNullStmt(NullStmt *S) { return true; }
bool WalkUpFromOMPCanonicalLoop(OMPCanonicalLoop *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitOMPCanonicalLoop(S)) return false; } while (false); return true; } bool VisitOMPCanonicalLoop(OMPCanonicalLoop *S) { return true; }
bool WalkUpFromOMPExecutableDirective(OMPExecutableDirective *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitOMPExecutableDirective(S)) return false; } while (false); return true; } bool VisitOMPExecutableDirective(OMPExecutableDirective *S) { return true; }
bool WalkUpFromOMPAtomicDirective(OMPAtomicDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPAtomicDirective(S)) return false; } while (false); return true; } bool VisitOMPAtomicDirective(OMPAtomicDirective *S) { return true; }
bool WalkUpFromOMPBarrierDirective(OMPBarrierDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPBarrierDirective(S)) return false; } while (false); return true; } bool VisitOMPBarrierDirective(OMPBarrierDirective *S) { return true; }
bool WalkUpFromOMPCancelDirective(OMPCancelDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPCancelDirective(S)) return false; } while (false); return true; } bool VisitOMPCancelDirective(OMPCancelDirective *S) { return true; }
bool WalkUpFromOMPCancellationPointDirective(OMPCancellationPointDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPCancellationPointDirective(S)) return false; } while (false); return true; } bool VisitOMPCancellationPointDirective(OMPCancellationPointDirective *S) { return true; }
bool WalkUpFromOMPCriticalDirective(OMPCriticalDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPCriticalDirective(S)) return false; } while (false); return true; } bool VisitOMPCriticalDirective(OMPCriticalDirective *S) { return true; }
bool WalkUpFromOMPDepobjDirective(OMPDepobjDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPDepobjDirective(S)) return false; } while (false); return true; } bool VisitOMPDepobjDirective(OMPDepobjDirective *S) { return true; }
bool WalkUpFromOMPDispatchDirective(OMPDispatchDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPDispatchDirective(S)) return false; } while (false); return true; } bool VisitOMPDispatchDirective(OMPDispatchDirective *S) { return true; }
bool WalkUpFromOMPFlushDirective(OMPFlushDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPFlushDirective(S)) return false; } while (false); return true; } bool VisitOMPFlushDirective(OMPFlushDirective *S) { return true; }
bool WalkUpFromOMPInteropDirective(OMPInteropDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPInteropDirective(S)) return false; } while (false); return true; } bool VisitOMPInteropDirective(OMPInteropDirective *S) { return true; }
bool WalkUpFromOMPLoopBasedDirective(OMPLoopBasedDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPLoopBasedDirective(S)) return false; } while (false); return true; } bool VisitOMPLoopBasedDirective(OMPLoopBasedDirective *S) { return true; }
bool WalkUpFromOMPLoopDirective(OMPLoopDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopBasedDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPLoopDirective(S)) return false; } while (false); return true; } bool VisitOMPLoopDirective(OMPLoopDirective *S) { return true; }
bool WalkUpFromOMPDistributeDirective(OMPDistributeDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPDistributeDirective(S)) return false; } while (false); return true; } bool VisitOMPDistributeDirective(OMPDistributeDirective *S) { return true; }
bool WalkUpFromOMPDistributeParallelForDirective(OMPDistributeParallelForDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPDistributeParallelForDirective(S)) return false; } while (false); return true; } bool VisitOMPDistributeParallelForDirective(OMPDistributeParallelForDirective *S) { return true; }
bool WalkUpFromOMPDistributeParallelForSimdDirective(OMPDistributeParallelForSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPDistributeParallelForSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPDistributeParallelForSimdDirective(OMPDistributeParallelForSimdDirective *S) { return true; }
bool WalkUpFromOMPDistributeSimdDirective(OMPDistributeSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPDistributeSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPDistributeSimdDirective(OMPDistributeSimdDirective *S) { return true; }
bool WalkUpFromOMPForDirective(OMPForDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPForDirective(S)) return false; } while (false); return true; } bool VisitOMPForDirective(OMPForDirective *S) { return true; }
bool WalkUpFromOMPForSimdDirective(OMPForSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPForSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPForSimdDirective(OMPForSimdDirective *S) { return true; }
bool WalkUpFromOMPMasterTaskLoopDirective(OMPMasterTaskLoopDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPMasterTaskLoopDirective(S)) return false; } while (false); return true; } bool VisitOMPMasterTaskLoopDirective(OMPMasterTaskLoopDirective *S) { return true; }
bool WalkUpFromOMPMasterTaskLoopSimdDirective(OMPMasterTaskLoopSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPMasterTaskLoopSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPMasterTaskLoopSimdDirective(OMPMasterTaskLoopSimdDirective *S) { return true; }
bool WalkUpFromOMPParallelForDirective(OMPParallelForDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPParallelForDirective(S)) return false; } while (false); return true; } bool VisitOMPParallelForDirective(OMPParallelForDirective *S) { return true; }
bool WalkUpFromOMPParallelForSimdDirective(OMPParallelForSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPParallelForSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPParallelForSimdDirective(OMPParallelForSimdDirective *S) { return true; }
bool WalkUpFromOMPParallelMasterTaskLoopDirective(OMPParallelMasterTaskLoopDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPParallelMasterTaskLoopDirective(S)) return false; } while (false); return true; } bool VisitOMPParallelMasterTaskLoopDirective(OMPParallelMasterTaskLoopDirective *S) { return true; }
bool WalkUpFromOMPParallelMasterTaskLoopSimdDirective(OMPParallelMasterTaskLoopSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPParallelMasterTaskLoopSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPParallelMasterTaskLoopSimdDirective(OMPParallelMasterTaskLoopSimdDirective *S) { return true; }
bool WalkUpFromOMPSimdDirective(OMPSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPSimdDirective(OMPSimdDirective *S) { return true; }
bool WalkUpFromOMPTargetParallelForSimdDirective(OMPTargetParallelForSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetParallelForSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetParallelForSimdDirective(OMPTargetParallelForSimdDirective *S) { return true; }
bool WalkUpFromOMPTargetSimdDirective(OMPTargetSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetSimdDirective(OMPTargetSimdDirective *S) { return true; }
bool WalkUpFromOMPTargetTeamsDistributeDirective(OMPTargetTeamsDistributeDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetTeamsDistributeDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetTeamsDistributeDirective(OMPTargetTeamsDistributeDirective *S) { return true; }
bool WalkUpFromOMPTargetTeamsDistributeParallelForDirective(OMPTargetTeamsDistributeParallelForDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetTeamsDistributeParallelForDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetTeamsDistributeParallelForDirective(OMPTargetTeamsDistributeParallelForDirective *S) { return true; }
bool WalkUpFromOMPTargetTeamsDistributeParallelForSimdDirective(OMPTargetTeamsDistributeParallelForSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetTeamsDistributeParallelForSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetTeamsDistributeParallelForSimdDirective(OMPTargetTeamsDistributeParallelForSimdDirective *S) { return true; }
bool WalkUpFromOMPTargetTeamsDistributeSimdDirective(OMPTargetTeamsDistributeSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetTeamsDistributeSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetTeamsDistributeSimdDirective(OMPTargetTeamsDistributeSimdDirective *S) { return true; }
bool WalkUpFromOMPTaskLoopDirective(OMPTaskLoopDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTaskLoopDirective(S)) return false; } while (false); return true; } bool VisitOMPTaskLoopDirective(OMPTaskLoopDirective *S) { return true; }
bool WalkUpFromOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTaskLoopSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *S) { return true; }
bool WalkUpFromOMPTeamsDistributeDirective(OMPTeamsDistributeDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTeamsDistributeDirective(S)) return false; } while (false); return true; } bool VisitOMPTeamsDistributeDirective(OMPTeamsDistributeDirective *S) { return true; }
bool WalkUpFromOMPTeamsDistributeParallelForDirective(OMPTeamsDistributeParallelForDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTeamsDistributeParallelForDirective(S)) return false; } while (false); return true; } bool VisitOMPTeamsDistributeParallelForDirective(OMPTeamsDistributeParallelForDirective *S) { return true; }
bool WalkUpFromOMPTeamsDistributeParallelForSimdDirective(OMPTeamsDistributeParallelForSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTeamsDistributeParallelForSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPTeamsDistributeParallelForSimdDirective(OMPTeamsDistributeParallelForSimdDirective *S) { return true; }
bool WalkUpFromOMPTeamsDistributeSimdDirective(OMPTeamsDistributeSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTeamsDistributeSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPTeamsDistributeSimdDirective(OMPTeamsDistributeSimdDirective *S) { return true; }
bool WalkUpFromOMPTileDirective(OMPTileDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopBasedDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTileDirective(S)) return false; } while (false); return true; } bool VisitOMPTileDirective(OMPTileDirective *S) { return true; }
bool WalkUpFromOMPUnrollDirective(OMPUnrollDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopBasedDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPUnrollDirective(S)) return false; } while (false); return true; } bool VisitOMPUnrollDirective(OMPUnrollDirective *S) { return true; }
bool WalkUpFromOMPMaskedDirective(OMPMaskedDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPMaskedDirective(S)) return false; } while (false); return true; } bool VisitOMPMaskedDirective(OMPMaskedDirective *S) { return true; }
bool WalkUpFromOMPMasterDirective(OMPMasterDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPMasterDirective(S)) return false; } while (false); return true; } bool VisitOMPMasterDirective(OMPMasterDirective *S) { return true; }
bool WalkUpFromOMPOrderedDirective(OMPOrderedDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPOrderedDirective(S)) return false; } while (false); return true; } bool VisitOMPOrderedDirective(OMPOrderedDirective *S) { return true; }
bool WalkUpFromOMPParallelDirective(OMPParallelDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPParallelDirective(S)) return false; } while (false); return true; } bool VisitOMPParallelDirective(OMPParallelDirective *S) { return true; }
bool WalkUpFromOMPParallelMasterDirective(OMPParallelMasterDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPParallelMasterDirective(S)) return false; } while (false); return true; } bool VisitOMPParallelMasterDirective(OMPParallelMasterDirective *S) { return true; }
bool WalkUpFromOMPParallelSectionsDirective(OMPParallelSectionsDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPParallelSectionsDirective(S)) return false; } while (false); return true; } bool VisitOMPParallelSectionsDirective(OMPParallelSectionsDirective *S) { return true; }
bool WalkUpFromOMPScanDirective(OMPScanDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPScanDirective(S)) return false; } while (false); return true; } bool VisitOMPScanDirective(OMPScanDirective *S) { return true; }
bool WalkUpFromOMPSectionDirective(OMPSectionDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPSectionDirective(S)) return false; } while (false); return true; } bool VisitOMPSectionDirective(OMPSectionDirective *S) { return true; }
bool WalkUpFromOMPSectionsDirective(OMPSectionsDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPSectionsDirective(S)) return false; } while (false); return true; } bool VisitOMPSectionsDirective(OMPSectionsDirective *S) { return true; }
bool WalkUpFromOMPSingleDirective(OMPSingleDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPSingleDirective(S)) return false; } while (false); return true; } bool VisitOMPSingleDirective(OMPSingleDirective *S) { return true; }
bool WalkUpFromOMPTargetDataDirective(OMPTargetDataDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetDataDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetDataDirective(OMPTargetDataDirective *S) { return true; }
bool WalkUpFromOMPTargetDirective(OMPTargetDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetDirective(OMPTargetDirective *S) { return true; }
bool WalkUpFromOMPTargetEnterDataDirective(OMPTargetEnterDataDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetEnterDataDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetEnterDataDirective(OMPTargetEnterDataDirective *S) { return true; }
bool WalkUpFromOMPTargetExitDataDirective(OMPTargetExitDataDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetExitDataDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetExitDataDirective(OMPTargetExitDataDirective *S) { return true; }
bool WalkUpFromOMPTargetParallelDirective(OMPTargetParallelDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetParallelDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetParallelDirective(OMPTargetParallelDirective *S) { return true; }
bool WalkUpFromOMPTargetParallelForDirective(OMPTargetParallelForDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetParallelForDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetParallelForDirective(OMPTargetParallelForDirective *S) { return true; }
bool WalkUpFromOMPTargetTeamsDirective(OMPTargetTeamsDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetTeamsDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *S) { return true; }
bool WalkUpFromOMPTargetUpdateDirective(OMPTargetUpdateDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetUpdateDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *S) { return true; }
bool WalkUpFromOMPTaskDirective(OMPTaskDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTaskDirective(S)) return false; } while (false); return true; } bool VisitOMPTaskDirective(OMPTaskDirective *S) { return true; }
bool WalkUpFromOMPTaskgroupDirective(OMPTaskgroupDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTaskgroupDirective(S)) return false; } while (false); return true; } bool VisitOMPTaskgroupDirective(OMPTaskgroupDirective *S) { return true; }
bool WalkUpFromOMPTaskwaitDirective(OMPTaskwaitDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTaskwaitDirective(S)) return false; } while (false); return true; } bool VisitOMPTaskwaitDirective(OMPTaskwaitDirective *S) { return true; }
bool WalkUpFromOMPTaskyieldDirective(OMPTaskyieldDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTaskyieldDirective(S)) return false; } while (false); return true; } bool VisitOMPTaskyieldDirective(OMPTaskyieldDirective *S) { return true; }
bool WalkUpFromOMPTeamsDirective(OMPTeamsDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTeamsDirective(S)) return false; } while (false); return true; } bool VisitOMPTeamsDirective(OMPTeamsDirective *S) { return true; }
bool WalkUpFromObjCAtCatchStmt(ObjCAtCatchStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitObjCAtCatchStmt(S)) return false; } while (false); return true; } bool VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { return true; }
bool WalkUpFromObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitObjCAtFinallyStmt(S)) return false; } while (false); return true; } bool VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { return true; }
bool WalkUpFromObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitObjCAtSynchronizedStmt(S)) return false; } while (false); return true; } bool VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) { return true; }
bool WalkUpFromObjCAtThrowStmt(ObjCAtThrowStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitObjCAtThrowStmt(S)) return false; } while (false); return true; } bool VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { return true; }
bool WalkUpFromObjCAtTryStmt(ObjCAtTryStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitObjCAtTryStmt(S)) return false; } while (false); return true; } bool VisitObjCAtTryStmt(ObjCAtTryStmt *S) { return true; }
bool WalkUpFromObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitObjCAutoreleasePoolStmt(S)) return false; } while (false); return true; } bool VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) { return true; }
bool WalkUpFromObjCForCollectionStmt(ObjCForCollectionStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitObjCForCollectionStmt(S)) return false; } while (false); return true; } bool VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { return true; }
bool WalkUpFromReturnStmt(ReturnStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitReturnStmt(S)) return false; } while (false); return true; } bool VisitReturnStmt(ReturnStmt *S) { return true; }
bool WalkUpFromSEHExceptStmt(SEHExceptStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitSEHExceptStmt(S)) return false; } while (false); return true; } bool VisitSEHExceptStmt(SEHExceptStmt *S) { return true; }
bool WalkUpFromSEHFinallyStmt(SEHFinallyStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitSEHFinallyStmt(S)) return false; } while (false); return true; } bool VisitSEHFinallyStmt(SEHFinallyStmt *S) { return true; }
bool WalkUpFromSEHLeaveStmt(SEHLeaveStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitSEHLeaveStmt(S)) return false; } while (false); return true; } bool VisitSEHLeaveStmt(SEHLeaveStmt *S) { return true; }
bool WalkUpFromSEHTryStmt(SEHTryStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitSEHTryStmt(S)) return false; } while (false); return true; } bool VisitSEHTryStmt(SEHTryStmt *S) { return true; }
bool WalkUpFromSwitchCase(SwitchCase *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitSwitchCase(S)) return false; } while (false); return true; } bool VisitSwitchCase(SwitchCase *S) { return true; }
bool WalkUpFromCaseStmt(CaseStmt *S) { do { if (!getDerived().WalkUpFromSwitchCase(S)) return false; } while (false); do { if (!getDerived().VisitCaseStmt(S)) return false; } while (false); return true; } bool VisitCaseStmt(CaseStmt *S) { return true; }
bool WalkUpFromDefaultStmt(DefaultStmt *S) { do { if (!getDerived().WalkUpFromSwitchCase(S)) return false; } while (false); do { if (!getDerived().VisitDefaultStmt(S)) return false; } while (false); return true; } bool VisitDefaultStmt(DefaultStmt *S) { return true; }
bool WalkUpFromSwitchStmt(SwitchStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitSwitchStmt(S)) return false; } while (false); return true; } bool VisitSwitchStmt(SwitchStmt *S) { return true; }
bool WalkUpFromValueStmt(ValueStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitValueStmt(S)) return false; } while (false); return true; } bool VisitValueStmt(ValueStmt *S) { return true; }
bool WalkUpFromAttributedStmt(AttributedStmt *S) { do { if (!getDerived().WalkUpFromValueStmt(S)) return false; } while (false); do { if (!getDerived().VisitAttributedStmt(S)) return false; } while (false); return true; } bool VisitAttributedStmt(AttributedStmt *S) { return true; }
bool WalkUpFromExpr(Expr *S) { do { if (!getDerived().WalkUpFromValueStmt(S)) return false; } while (false); do { if (!getDerived().VisitExpr(S)) return false; } while (false); return true; } bool VisitExpr(Expr *S) { return true; }
bool WalkUpFromAbstractConditionalOperator(AbstractConditionalOperator *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitAbstractConditionalOperator(S)) return false; } while (false); return true; } bool VisitAbstractConditionalOperator(AbstractConditionalOperator *S) { return true; }
bool WalkUpFromBinaryConditionalOperator(BinaryConditionalOperator *S) { do { if (!getDerived().WalkUpFromAbstractConditionalOperator(S)) return false; } while (false); do { if (!getDerived().VisitBinaryConditionalOperator(S)) return false; } while (false); return true; } bool VisitBinaryConditionalOperator(BinaryConditionalOperator *S) { return true; }
bool WalkUpFromConditionalOperator(ConditionalOperator *S) { do { if (!getDerived().WalkUpFromAbstractConditionalOperator(S)) return false; } while (false); do { if (!getDerived().VisitConditionalOperator(S)) return false; } while (false); return true; } bool VisitConditionalOperator(ConditionalOperator *S) { return true; }
bool WalkUpFromAddrLabelExpr(AddrLabelExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitAddrLabelExpr(S)) return false; } while (false); return true; } bool VisitAddrLabelExpr(AddrLabelExpr *S) { return true; }
bool WalkUpFromArrayInitIndexExpr(ArrayInitIndexExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitArrayInitIndexExpr(S)) return false; } while (false); return true; } bool VisitArrayInitIndexExpr(ArrayInitIndexExpr *S) { return true; }
bool WalkUpFromArrayInitLoopExpr(ArrayInitLoopExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitArrayInitLoopExpr(S)) return false; } while (false); return true; } bool VisitArrayInitLoopExpr(ArrayInitLoopExpr *S) { return true; }
bool WalkUpFromArraySubscriptExpr(ArraySubscriptExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitArraySubscriptExpr(S)) return false; } while (false); return true; } bool VisitArraySubscriptExpr(ArraySubscriptExpr *S) { return true; }
bool WalkUpFromArrayTypeTraitExpr(ArrayTypeTraitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitArrayTypeTraitExpr(S)) return false; } while (false); return true; } bool VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *S) { return true; }
bool WalkUpFromAsTypeExpr(AsTypeExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitAsTypeExpr(S)) return false; } while (false); return true; } bool VisitAsTypeExpr(AsTypeExpr *S) { return true; }
bool WalkUpFromAtomicExpr(AtomicExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitAtomicExpr(S)) return false; } while (false); return true; } bool VisitAtomicExpr(AtomicExpr *S) { return true; }
bool WalkUpFromBinaryOperator(BinaryOperator *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitBinaryOperator(S)) return false; } while (false); return true; } bool VisitBinaryOperator(BinaryOperator *S) { return true; }
bool WalkUpFromCompoundAssignOperator(CompoundAssignOperator *S) { do { if (!getDerived().WalkUpFromBinaryOperator(S)) return false; } while (false); do { if (!getDerived().VisitCompoundAssignOperator(S)) return false; } while (false); return true; } bool VisitCompoundAssignOperator(CompoundAssignOperator *S) { return true; }
bool WalkUpFromBlockExpr(BlockExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitBlockExpr(S)) return false; } while (false); return true; } bool VisitBlockExpr(BlockExpr *S) { return true; }
bool WalkUpFromCXXBindTemporaryExpr(CXXBindTemporaryExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXBindTemporaryExpr(S)) return false; } while (false); return true; } bool VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *S) { return true; }
bool WalkUpFromCXXBoolLiteralExpr(CXXBoolLiteralExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXBoolLiteralExpr(S)) return false; } while (false); return true; } bool VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *S) { return true; }
bool WalkUpFromCXXConstructExpr(CXXConstructExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXConstructExpr(S)) return false; } while (false); return true; } bool VisitCXXConstructExpr(CXXConstructExpr *S) { return true; }
bool WalkUpFromCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *S) { do { if (!getDerived().WalkUpFromCXXConstructExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXTemporaryObjectExpr(S)) return false; } while (false); return true; } bool VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *S) { return true; }
bool WalkUpFromCXXDefaultArgExpr(CXXDefaultArgExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXDefaultArgExpr(S)) return false; } while (false); return true; } bool VisitCXXDefaultArgExpr(CXXDefaultArgExpr *S) { return true; }
bool WalkUpFromCXXDefaultInitExpr(CXXDefaultInitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXDefaultInitExpr(S)) return false; } while (false); return true; } bool VisitCXXDefaultInitExpr(CXXDefaultInitExpr *S) { return true; }
bool WalkUpFromCXXDeleteExpr(CXXDeleteExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXDeleteExpr(S)) return false; } while (false); return true; } bool VisitCXXDeleteExpr(CXXDeleteExpr *S) { return true; }
bool WalkUpFromCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXDependentScopeMemberExpr(S)) return false; } while (false); return true; } bool VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *S) { return true; }
bool WalkUpFromCXXFoldExpr(CXXFoldExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXFoldExpr(S)) return false; } while (false); return true; } bool VisitCXXFoldExpr(CXXFoldExpr *S) { return true; }
bool WalkUpFromCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXInheritedCtorInitExpr(S)) return false; } while (false); return true; } bool VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *S) { return true; }
bool WalkUpFromCXXNewExpr(CXXNewExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXNewExpr(S)) return false; } while (false); return true; } bool VisitCXXNewExpr(CXXNewExpr *S) { return true; }
bool WalkUpFromCXXNoexceptExpr(CXXNoexceptExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXNoexceptExpr(S)) return false; } while (false); return true; } bool VisitCXXNoexceptExpr(CXXNoexceptExpr *S) { return true; }
bool WalkUpFromCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXNullPtrLiteralExpr(S)) return false; } while (false); return true; } bool VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) { return true; }
bool WalkUpFromCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXPseudoDestructorExpr(S)) return false; } while (false); return true; } bool VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *S) { return true; }
bool WalkUpFromCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXRewrittenBinaryOperator(S)) return false; } while (false); return true; } bool VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *S) { return true; }
bool WalkUpFromCXXScalarValueInitExpr(CXXScalarValueInitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXScalarValueInitExpr(S)) return false; } while (false); return true; } bool VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *S) { return true; }
bool WalkUpFromCXXStdInitializerListExpr(CXXStdInitializerListExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXStdInitializerListExpr(S)) return false; } while (false); return true; } bool VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *S) { return true; }
bool WalkUpFromCXXThisExpr(CXXThisExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXThisExpr(S)) return false; } while (false); return true; } bool VisitCXXThisExpr(CXXThisExpr *S) { return true; }
bool WalkUpFromCXXThrowExpr(CXXThrowExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXThrowExpr(S)) return false; } while (false); return true; } bool VisitCXXThrowExpr(CXXThrowExpr *S) { return true; }
bool WalkUpFromCXXTypeidExpr(CXXTypeidExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXTypeidExpr(S)) return false; } while (false); return true; } bool VisitCXXTypeidExpr(CXXTypeidExpr *S) { return true; }
bool WalkUpFromCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXUnresolvedConstructExpr(S)) return false; } while (false); return true; } bool VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *S) { return true; }
bool WalkUpFromCXXUuidofExpr(CXXUuidofExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXUuidofExpr(S)) return false; } while (false); return true; } bool VisitCXXUuidofExpr(CXXUuidofExpr *S) { return true; }
bool WalkUpFromCallExpr(CallExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCallExpr(S)) return false; } while (false); return true; } bool VisitCallExpr(CallExpr *S) { return true; }
bool WalkUpFromCUDAKernelCallExpr(CUDAKernelCallExpr *S) { do { if (!getDerived().WalkUpFromCallExpr(S)) return false; } while (false); do { if (!getDerived().VisitCUDAKernelCallExpr(S)) return false; } while (false); return true; } bool VisitCUDAKernelCallExpr(CUDAKernelCallExpr *S) { return true; }
bool WalkUpFromCXXMemberCallExpr(CXXMemberCallExpr *S) { do { if (!getDerived().WalkUpFromCallExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXMemberCallExpr(S)) return false; } while (false); return true; } bool VisitCXXMemberCallExpr(CXXMemberCallExpr *S) { return true; }
bool WalkUpFromCXXOperatorCallExpr(CXXOperatorCallExpr *S) { do { if (!getDerived().WalkUpFromCallExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXOperatorCallExpr(S)) return false; } while (false); return true; } bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr *S) { return true; }
bool WalkUpFromUserDefinedLiteral(UserDefinedLiteral *S) { do { if (!getDerived().WalkUpFromCallExpr(S)) return false; } while (false); do { if (!getDerived().VisitUserDefinedLiteral(S)) return false; } while (false); return true; } bool VisitUserDefinedLiteral(UserDefinedLiteral *S) { return true; }
bool WalkUpFromCastExpr(CastExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCastExpr(S)) return false; } while (false); return true; } bool VisitCastExpr(CastExpr *S) { return true; }
bool WalkUpFromExplicitCastExpr(ExplicitCastExpr *S) { do { if (!getDerived().WalkUpFromCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitExplicitCastExpr(S)) return false; } while (false); return true; } bool VisitExplicitCastExpr(ExplicitCastExpr *S) { return true; }
bool WalkUpFromBuiltinBitCastExpr(BuiltinBitCastExpr *S) { do { if (!getDerived().WalkUpFromExplicitCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitBuiltinBitCastExpr(S)) return false; } while (false); return true; } bool VisitBuiltinBitCastExpr(BuiltinBitCastExpr *S) { return true; }
bool WalkUpFromCStyleCastExpr(CStyleCastExpr *S) { do { if (!getDerived().WalkUpFromExplicitCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitCStyleCastExpr(S)) return false; } while (false); return true; } bool VisitCStyleCastExpr(CStyleCastExpr *S) { return true; }
bool WalkUpFromCXXFunctionalCastExpr(CXXFunctionalCastExpr *S) { do { if (!getDerived().WalkUpFromExplicitCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXFunctionalCastExpr(S)) return false; } while (false); return true; } bool VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *S) { return true; }
bool WalkUpFromCXXNamedCastExpr(CXXNamedCastExpr *S) { do { if (!getDerived().WalkUpFromExplicitCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXNamedCastExpr(S)) return false; } while (false); return true; } bool VisitCXXNamedCastExpr(CXXNamedCastExpr *S) { return true; }
bool WalkUpFromCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *S) { do { if (!getDerived().WalkUpFromCXXNamedCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXAddrspaceCastExpr(S)) return false; } while (false); return true; } bool VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *S) { return true; }
bool WalkUpFromCXXConstCastExpr(CXXConstCastExpr *S) { do { if (!getDerived().WalkUpFromCXXNamedCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXConstCastExpr(S)) return false; } while (false); return true; } bool VisitCXXConstCastExpr(CXXConstCastExpr *S) { return true; }
bool WalkUpFromCXXDynamicCastExpr(CXXDynamicCastExpr *S) { do { if (!getDerived().WalkUpFromCXXNamedCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXDynamicCastExpr(S)) return false; } while (false); return true; } bool VisitCXXDynamicCastExpr(CXXDynamicCastExpr *S) { return true; }
bool WalkUpFromCXXReinterpretCastExpr(CXXReinterpretCastExpr *S) { do { if (!getDerived().WalkUpFromCXXNamedCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXReinterpretCastExpr(S)) return false; } while (false); return true; } bool VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *S) { return true; }
bool WalkUpFromCXXStaticCastExpr(CXXStaticCastExpr *S) { do { if (!getDerived().WalkUpFromCXXNamedCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXStaticCastExpr(S)) return false; } while (false); return true; } bool VisitCXXStaticCastExpr(CXXStaticCastExpr *S) { return true; }
bool WalkUpFromObjCBridgedCastExpr(ObjCBridgedCastExpr *S) { do { if (!getDerived().WalkUpFromExplicitCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCBridgedCastExpr(S)) return false; } while (false); return true; } bool VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *S) { return true; }
bool WalkUpFromImplicitCastExpr(ImplicitCastExpr *S) { do { if (!getDerived().WalkUpFromCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitImplicitCastExpr(S)) return false; } while (false); return true; } bool VisitImplicitCastExpr(ImplicitCastExpr *S) { return true; }
bool WalkUpFromCharacterLiteral(CharacterLiteral *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCharacterLiteral(S)) return false; } while (false); return true; } bool VisitCharacterLiteral(CharacterLiteral *S) { return true; }
bool WalkUpFromChooseExpr(ChooseExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitChooseExpr(S)) return false; } while (false); return true; } bool VisitChooseExpr(ChooseExpr *S) { return true; }
bool WalkUpFromCompoundLiteralExpr(CompoundLiteralExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCompoundLiteralExpr(S)) return false; } while (false); return true; } bool VisitCompoundLiteralExpr(CompoundLiteralExpr *S) { return true; }
bool WalkUpFromConceptSpecializationExpr(ConceptSpecializationExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitConceptSpecializationExpr(S)) return false; } while (false); return true; } bool VisitConceptSpecializationExpr(ConceptSpecializationExpr *S) { return true; }
bool WalkUpFromConvertVectorExpr(ConvertVectorExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitConvertVectorExpr(S)) return false; } while (false); return true; } bool VisitConvertVectorExpr(ConvertVectorExpr *S) { return true; }
bool WalkUpFromCoroutineSuspendExpr(CoroutineSuspendExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCoroutineSuspendExpr(S)) return false; } while (false); return true; } bool VisitCoroutineSuspendExpr(CoroutineSuspendExpr *S) { return true; }
bool WalkUpFromCoawaitExpr(CoawaitExpr *S) { do { if (!getDerived().WalkUpFromCoroutineSuspendExpr(S)) return false; } while (false); do { if (!getDerived().VisitCoawaitExpr(S)) return false; } while (false); return true; } bool VisitCoawaitExpr(CoawaitExpr *S) { return true; }
bool WalkUpFromCoyieldExpr(CoyieldExpr *S) { do { if (!getDerived().WalkUpFromCoroutineSuspendExpr(S)) return false; } while (false); do { if (!getDerived().VisitCoyieldExpr(S)) return false; } while (false); return true; } bool VisitCoyieldExpr(CoyieldExpr *S) { return true; }
bool WalkUpFromDeclRefExpr(DeclRefExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitDeclRefExpr(S)) return false; } while (false); return true; } bool VisitDeclRefExpr(DeclRefExpr *S) { return true; }
bool WalkUpFromDependentCoawaitExpr(DependentCoawaitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitDependentCoawaitExpr(S)) return false; } while (false); return true; } bool VisitDependentCoawaitExpr(DependentCoawaitExpr *S) { return true; }
bool WalkUpFromDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitDependentScopeDeclRefExpr(S)) return false; } while (false); return true; } bool VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *S) { return true; }
bool WalkUpFromDesignatedInitExpr(DesignatedInitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitDesignatedInitExpr(S)) return false; } while (false); return true; } bool VisitDesignatedInitExpr(DesignatedInitExpr *S) { return true; }
bool WalkUpFromDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitDesignatedInitUpdateExpr(S)) return false; } while (false); return true; } bool VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *S) { return true; }
bool WalkUpFromExpressionTraitExpr(ExpressionTraitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitExpressionTraitExpr(S)) return false; } while (false); return true; } bool VisitExpressionTraitExpr(ExpressionTraitExpr *S) { return true; }
bool WalkUpFromExtVectorElementExpr(ExtVectorElementExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitExtVectorElementExpr(S)) return false; } while (false); return true; } bool VisitExtVectorElementExpr(ExtVectorElementExpr *S) { return true; }
bool WalkUpFromFixedPointLiteral(FixedPointLiteral *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitFixedPointLiteral(S)) return false; } while (false); return true; } bool VisitFixedPointLiteral(FixedPointLiteral *S) { return true; }
bool WalkUpFromFloatingLiteral(FloatingLiteral *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitFloatingLiteral(S)) return false; } while (false); return true; } bool VisitFloatingLiteral(FloatingLiteral *S) { return true; }
bool WalkUpFromFullExpr(FullExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitFullExpr(S)) return false; } while (false); return true; } bool VisitFullExpr(FullExpr *S) { return true; }
bool WalkUpFromConstantExpr(ConstantExpr *S) { do { if (!getDerived().WalkUpFromFullExpr(S)) return false; } while (false); do { if (!getDerived().VisitConstantExpr(S)) return false; } while (false); return true; } bool VisitConstantExpr(ConstantExpr *S) { return true; }
bool WalkUpFromExprWithCleanups(ExprWithCleanups *S) { do { if (!getDerived().WalkUpFromFullExpr(S)) return false; } while (false); do { if (!getDerived().VisitExprWithCleanups(S)) return false; } while (false); return true; } bool VisitExprWithCleanups(ExprWithCleanups *S) { return true; }
bool WalkUpFromFunctionParmPackExpr(FunctionParmPackExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitFunctionParmPackExpr(S)) return false; } while (false); return true; } bool VisitFunctionParmPackExpr(FunctionParmPackExpr *S) { return true; }
bool WalkUpFromGNUNullExpr(GNUNullExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitGNUNullExpr(S)) return false; } while (false); return true; } bool VisitGNUNullExpr(GNUNullExpr *S) { return true; }
bool WalkUpFromGenericSelectionExpr(GenericSelectionExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitGenericSelectionExpr(S)) return false; } while (false); return true; } bool VisitGenericSelectionExpr(GenericSelectionExpr *S) { return true; }
bool WalkUpFromImaginaryLiteral(ImaginaryLiteral *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitImaginaryLiteral(S)) return false; } while (false); return true; } bool VisitImaginaryLiteral(ImaginaryLiteral *S) { return true; }
bool WalkUpFromImplicitValueInitExpr(ImplicitValueInitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitImplicitValueInitExpr(S)) return false; } while (false); return true; } bool VisitImplicitValueInitExpr(ImplicitValueInitExpr *S) { return true; }
bool WalkUpFromInitListExpr(InitListExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitInitListExpr(S)) return false; } while (false); return true; } bool VisitInitListExpr(InitListExpr *S) { return true; }
bool WalkUpFromIntegerLiteral(IntegerLiteral *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitIntegerLiteral(S)) return false; } while (false); return true; } bool VisitIntegerLiteral(IntegerLiteral *S) { return true; }
bool WalkUpFromLambdaExpr(LambdaExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitLambdaExpr(S)) return false; } while (false); return true; } bool VisitLambdaExpr(LambdaExpr *S) { return true; }
bool WalkUpFromMSPropertyRefExpr(MSPropertyRefExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitMSPropertyRefExpr(S)) return false; } while (false); return true; } bool VisitMSPropertyRefExpr(MSPropertyRefExpr *S) { return true; }
bool WalkUpFromMSPropertySubscriptExpr(MSPropertySubscriptExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitMSPropertySubscriptExpr(S)) return false; } while (false); return true; } bool VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *S) { return true; }
bool WalkUpFromMaterializeTemporaryExpr(MaterializeTemporaryExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitMaterializeTemporaryExpr(S)) return false; } while (false); return true; } bool VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *S) { return true; }
bool WalkUpFromMatrixSubscriptExpr(MatrixSubscriptExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitMatrixSubscriptExpr(S)) return false; } while (false); return true; } bool VisitMatrixSubscriptExpr(MatrixSubscriptExpr *S) { return true; }
bool WalkUpFromMemberExpr(MemberExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitMemberExpr(S)) return false; } while (false); return true; } bool VisitMemberExpr(MemberExpr *S) { return true; }
bool WalkUpFromNoInitExpr(NoInitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitNoInitExpr(S)) return false; } while (false); return true; } bool VisitNoInitExpr(NoInitExpr *S) { return true; }
bool WalkUpFromOMPArraySectionExpr(OMPArraySectionExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitOMPArraySectionExpr(S)) return false; } while (false); return true; } bool VisitOMPArraySectionExpr(OMPArraySectionExpr *S) { return true; }
bool WalkUpFromOMPArrayShapingExpr(OMPArrayShapingExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitOMPArrayShapingExpr(S)) return false; } while (false); return true; } bool VisitOMPArrayShapingExpr(OMPArrayShapingExpr *S) { return true; }
bool WalkUpFromOMPIteratorExpr(OMPIteratorExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitOMPIteratorExpr(S)) return false; } while (false); return true; } bool VisitOMPIteratorExpr(OMPIteratorExpr *S) { return true; }
bool WalkUpFromObjCArrayLiteral(ObjCArrayLiteral *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCArrayLiteral(S)) return false; } while (false); return true; } bool VisitObjCArrayLiteral(ObjCArrayLiteral *S) { return true; }
bool WalkUpFromObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCAvailabilityCheckExpr(S)) return false; } while (false); return true; } bool VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *S) { return true; }
bool WalkUpFromObjCBoolLiteralExpr(ObjCBoolLiteralExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCBoolLiteralExpr(S)) return false; } while (false); return true; } bool VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *S) { return true; }
bool WalkUpFromObjCBoxedExpr(ObjCBoxedExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCBoxedExpr(S)) return false; } while (false); return true; } bool VisitObjCBoxedExpr(ObjCBoxedExpr *S) { return true; }
bool WalkUpFromObjCDictionaryLiteral(ObjCDictionaryLiteral *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCDictionaryLiteral(S)) return false; } while (false); return true; } bool VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *S) { return true; }
bool WalkUpFromObjCEncodeExpr(ObjCEncodeExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCEncodeExpr(S)) return false; } while (false); return true; } bool VisitObjCEncodeExpr(ObjCEncodeExpr *S) { return true; }
bool WalkUpFromObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCIndirectCopyRestoreExpr(S)) return false; } while (false); return true; } bool VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *S) { return true; }
bool WalkUpFromObjCIsaExpr(ObjCIsaExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCIsaExpr(S)) return false; } while (false); return true; } bool VisitObjCIsaExpr(ObjCIsaExpr *S) { return true; }
bool WalkUpFromObjCIvarRefExpr(ObjCIvarRefExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCIvarRefExpr(S)) return false; } while (false); return true; } bool VisitObjCIvarRefExpr(ObjCIvarRefExpr *S) { return true; }
bool WalkUpFromObjCMessageExpr(ObjCMessageExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCMessageExpr(S)) return false; } while (false); return true; } bool VisitObjCMessageExpr(ObjCMessageExpr *S) { return true; }
bool WalkUpFromObjCPropertyRefExpr(ObjCPropertyRefExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCPropertyRefExpr(S)) return false; } while (false); return true; } bool VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *S) { return true; }
bool WalkUpFromObjCProtocolExpr(ObjCProtocolExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCProtocolExpr(S)) return false; } while (false); return true; } bool VisitObjCProtocolExpr(ObjCProtocolExpr *S) { return true; }
bool WalkUpFromObjCSelectorExpr(ObjCSelectorExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCSelectorExpr(S)) return false; } while (false); return true; } bool VisitObjCSelectorExpr(ObjCSelectorExpr *S) { return true; }
bool WalkUpFromObjCStringLiteral(ObjCStringLiteral *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCStringLiteral(S)) return false; } while (false); return true; } bool VisitObjCStringLiteral(ObjCStringLiteral *S) { return true; }
bool WalkUpFromObjCSubscriptRefExpr(ObjCSubscriptRefExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCSubscriptRefExpr(S)) return false; } while (false); return true; } bool VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *S) { return true; }
bool WalkUpFromOffsetOfExpr(OffsetOfExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitOffsetOfExpr(S)) return false; } while (false); return true; } bool VisitOffsetOfExpr(OffsetOfExpr *S) { return true; }
bool WalkUpFromOpaqueValueExpr(OpaqueValueExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitOpaqueValueExpr(S)) return false; } while (false); return true; } bool VisitOpaqueValueExpr(OpaqueValueExpr *S) { return true; }
bool WalkUpFromOverloadExpr(OverloadExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitOverloadExpr(S)) return false; } while (false); return true; } bool VisitOverloadExpr(OverloadExpr *S) { return true; }
bool WalkUpFromUnresolvedLookupExpr(UnresolvedLookupExpr *S) { do { if (!getDerived().WalkUpFromOverloadExpr(S)) return false; } while (false); do { if (!getDerived().VisitUnresolvedLookupExpr(S)) return false; } while (false); return true; } bool VisitUnresolvedLookupExpr(UnresolvedLookupExpr *S) { return true; }
bool WalkUpFromUnresolvedMemberExpr(UnresolvedMemberExpr *S) { do { if (!getDerived().WalkUpFromOverloadExpr(S)) return false; } while (false); do { if (!getDerived().VisitUnresolvedMemberExpr(S)) return false; } while (false); return true; } bool VisitUnresolvedMemberExpr(UnresolvedMemberExpr *S) { return true; }
bool WalkUpFromPackExpansionExpr(PackExpansionExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitPackExpansionExpr(S)) return false; } while (false); return true; } bool VisitPackExpansionExpr(PackExpansionExpr *S) { return true; }
bool WalkUpFromParenExpr(ParenExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitParenExpr(S)) return false; } while (false); return true; } bool VisitParenExpr(ParenExpr *S) { return true; }
bool WalkUpFromParenListExpr(ParenListExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitParenListExpr(S)) return false; } while (false); return true; } bool VisitParenListExpr(ParenListExpr *S) { return true; }
bool WalkUpFromPredefinedExpr(PredefinedExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitPredefinedExpr(S)) return false; } while (false); return true; } bool VisitPredefinedExpr(PredefinedExpr *S) { return true; }
bool WalkUpFromPseudoObjectExpr(PseudoObjectExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitPseudoObjectExpr(S)) return false; } while (false); return true; } bool VisitPseudoObjectExpr(PseudoObjectExpr *S) { return true; }
bool WalkUpFromRecoveryExpr(RecoveryExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitRecoveryExpr(S)) return false; } while (false); return true; } bool VisitRecoveryExpr(RecoveryExpr *S) { return true; }
bool WalkUpFromRequiresExpr(RequiresExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitRequiresExpr(S)) return false; } while (false); return true; } bool VisitRequiresExpr(RequiresExpr *S) { return true; }
bool WalkUpFromSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitSYCLUniqueStableNameExpr(S)) return false; } while (false); return true; } bool VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *S) { return true; }
bool WalkUpFromShuffleVectorExpr(ShuffleVectorExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitShuffleVectorExpr(S)) return false; } while (false); return true; } bool VisitShuffleVectorExpr(ShuffleVectorExpr *S) { return true; }
bool WalkUpFromSizeOfPackExpr(SizeOfPackExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitSizeOfPackExpr(S)) return false; } while (false); return true; } bool VisitSizeOfPackExpr(SizeOfPackExpr *S) { return true; }
bool WalkUpFromSourceLocExpr(SourceLocExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitSourceLocExpr(S)) return false; } while (false); return true; } bool VisitSourceLocExpr(SourceLocExpr *S) { return true; }
bool WalkUpFromStmtExpr(StmtExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitStmtExpr(S)) return false; } while (false); return true; } bool VisitStmtExpr(StmtExpr *S) { return true; }
bool WalkUpFromStringLiteral(StringLiteral *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitStringLiteral(S)) return false; } while (false); return true; } bool VisitStringLiteral(StringLiteral *S) { return true; }
bool WalkUpFromSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitSubstNonTypeTemplateParmExpr(S)) return false; } while (false); return true; } bool VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *S) { return true; }
bool WalkUpFromSubstNonTypeTemplateParmPackExpr(SubstNonTypeTemplateParmPackExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitSubstNonTypeTemplateParmPackExpr(S)) return false; } while (false); return true; } bool VisitSubstNonTypeTemplateParmPackExpr(SubstNonTypeTemplateParmPackExpr *S) { return true; }
bool WalkUpFromTypeTraitExpr(TypeTraitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitTypeTraitExpr(S)) return false; } while (false); return true; } bool VisitTypeTraitExpr(TypeTraitExpr *S) { return true; }
bool WalkUpFromTypoExpr(TypoExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitTypoExpr(S)) return false; } while (false); return true; } bool VisitTypoExpr(TypoExpr *S) { return true; }
bool WalkUpFromUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitUnaryExprOrTypeTraitExpr(S)) return false; } while (false); return true; } bool VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *S) { return true; }
bool WalkUpFromUnaryOperator(UnaryOperator *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitUnaryOperator(S)) return false; } while (false); return true; } bool VisitUnaryOperator(UnaryOperator *S) { return true; }
bool WalkUpFromVAArgExpr(VAArgExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitVAArgExpr(S)) return false; } while (false); return true; } bool VisitVAArgExpr(VAArgExpr *S) { return true; }
bool WalkUpFromLabelStmt(LabelStmt *S) { do { if (!getDerived().WalkUpFromValueStmt(S)) return false; } while (false); do { if (!getDerived().VisitLabelStmt(S)) return false; } while (false); return true; } bool VisitLabelStmt(LabelStmt *S) { return true; }
bool WalkUpFromWhileStmt(WhileStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitWhileStmt(S)) return false; } while (false); return true; } bool VisitWhileStmt(WhileStmt *S) { return true; }
bool TraverseAdjustedType(AdjustedType *T);
bool TraverseDecayedType(DecayedType *T);
bool TraverseConstantArrayType(ConstantArrayType *T);
bool TraverseDependentSizedArrayType(DependentSizedArrayType *T);
bool TraverseIncompleteArrayType(IncompleteArrayType *T);
bool TraverseVariableArrayType(VariableArrayType *T);
bool TraverseAtomicType(AtomicType *T);
bool TraverseAttributedType(AttributedType *T);
bool TraverseBlockPointerType(BlockPointerType *T);
bool TraverseBuiltinType(BuiltinType *T);
bool TraverseComplexType(ComplexType *T);
bool TraverseDecltypeType(DecltypeType *T);
bool TraverseAutoType(AutoType *T);
bool TraverseDeducedTemplateSpecializationType(DeducedTemplateSpecializationType *T);
bool TraverseDependentAddressSpaceType(DependentAddressSpaceType *T);
bool TraverseDependentExtIntType(DependentExtIntType *T);
bool TraverseDependentNameType(DependentNameType *T);
bool TraverseDependentSizedExtVectorType(DependentSizedExtVectorType *T);
bool TraverseDependentTemplateSpecializationType(DependentTemplateSpecializationType *T);
bool TraverseDependentVectorType(DependentVectorType *T);
bool TraverseElaboratedType(ElaboratedType *T);
bool TraverseExtIntType(ExtIntType *T);
bool TraverseFunctionNoProtoType(FunctionNoProtoType *T);
bool TraverseFunctionProtoType(FunctionProtoType *T);
bool TraverseInjectedClassNameType(InjectedClassNameType *T);
bool TraverseMacroQualifiedType(MacroQualifiedType *T);
bool TraverseConstantMatrixType(ConstantMatrixType *T);
bool TraverseDependentSizedMatrixType(DependentSizedMatrixType *T);
bool TraverseMemberPointerType(MemberPointerType *T);
bool TraverseObjCObjectPointerType(ObjCObjectPointerType *T);
bool TraverseObjCObjectType(ObjCObjectType *T);
bool TraverseObjCInterfaceType(ObjCInterfaceType *T);
bool TraverseObjCTypeParamType(ObjCTypeParamType *T);
bool TraversePackExpansionType(PackExpansionType *T);
bool TraverseParenType(ParenType *T);
bool TraversePipeType(PipeType *T);
bool TraversePointerType(PointerType *T);
bool TraverseLValueReferenceType(LValueReferenceType *T);
bool TraverseRValueReferenceType(RValueReferenceType *T);
bool TraverseSubstTemplateTypeParmPackType(SubstTemplateTypeParmPackType *T);
bool TraverseSubstTemplateTypeParmType(SubstTemplateTypeParmType *T);
bool TraverseEnumType(EnumType *T);
bool TraverseRecordType(RecordType *T);
bool TraverseTemplateSpecializationType(TemplateSpecializationType *T);
bool TraverseTemplateTypeParmType(TemplateTypeParmType *T);
bool TraverseTypeOfExprType(TypeOfExprType *T);
bool TraverseTypeOfType(TypeOfType *T);
bool TraverseTypedefType(TypedefType *T);
bool TraverseUnaryTransformType(UnaryTransformType *T);
bool TraverseUnresolvedUsingType(UnresolvedUsingType *T);
bool TraverseVectorType(VectorType *T);
bool TraverseExtVectorType(ExtVectorType *T);
  bool WalkUpFromType(Type *T) { return getDerived().VisitType(T); }
  bool VisitType(Type *T) { return true; }
bool WalkUpFromAdjustedType(AdjustedType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitAdjustedType(T)) return false; } while (false); return true; } bool VisitAdjustedType(AdjustedType *T) { return true; }
bool WalkUpFromDecayedType(DecayedType *T) { do { if (!getDerived().WalkUpFromAdjustedType(T)) return false; } while (false); do { if (!getDerived().VisitDecayedType(T)) return false; } while (false); return true; } bool VisitDecayedType(DecayedType *T) { return true; }
bool WalkUpFromArrayType(ArrayType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitArrayType(T)) return false; } while (false); return true; } bool VisitArrayType(ArrayType *T) { return true; }
bool WalkUpFromConstantArrayType(ConstantArrayType *T) { do { if (!getDerived().WalkUpFromArrayType(T)) return false; } while (false); do { if (!getDerived().VisitConstantArrayType(T)) return false; } while (false); return true; } bool VisitConstantArrayType(ConstantArrayType *T) { return true; }
bool WalkUpFromDependentSizedArrayType(DependentSizedArrayType *T) { do { if (!getDerived().WalkUpFromArrayType(T)) return false; } while (false); do { if (!getDerived().VisitDependentSizedArrayType(T)) return false; } while (false); return true; } bool VisitDependentSizedArrayType(DependentSizedArrayType *T) { return true; }
bool WalkUpFromIncompleteArrayType(IncompleteArrayType *T) { do { if (!getDerived().WalkUpFromArrayType(T)) return false; } while (false); do { if (!getDerived().VisitIncompleteArrayType(T)) return false; } while (false); return true; } bool VisitIncompleteArrayType(IncompleteArrayType *T) { return true; }
bool WalkUpFromVariableArrayType(VariableArrayType *T) { do { if (!getDerived().WalkUpFromArrayType(T)) return false; } while (false); do { if (!getDerived().VisitVariableArrayType(T)) return false; } while (false); return true; } bool VisitVariableArrayType(VariableArrayType *T) { return true; }
bool WalkUpFromAtomicType(AtomicType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitAtomicType(T)) return false; } while (false); return true; } bool VisitAtomicType(AtomicType *T) { return true; }
bool WalkUpFromAttributedType(AttributedType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitAttributedType(T)) return false; } while (false); return true; } bool VisitAttributedType(AttributedType *T) { return true; }
bool WalkUpFromBlockPointerType(BlockPointerType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitBlockPointerType(T)) return false; } while (false); return true; } bool VisitBlockPointerType(BlockPointerType *T) { return true; }
bool WalkUpFromBuiltinType(BuiltinType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitBuiltinType(T)) return false; } while (false); return true; } bool VisitBuiltinType(BuiltinType *T) { return true; }
bool WalkUpFromComplexType(ComplexType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitComplexType(T)) return false; } while (false); return true; } bool VisitComplexType(ComplexType *T) { return true; }
bool WalkUpFromDecltypeType(DecltypeType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitDecltypeType(T)) return false; } while (false); return true; } bool VisitDecltypeType(DecltypeType *T) { return true; }
bool WalkUpFromDeducedType(DeducedType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitDeducedType(T)) return false; } while (false); return true; } bool VisitDeducedType(DeducedType *T) { return true; }
bool WalkUpFromAutoType(AutoType *T) { do { if (!getDerived().WalkUpFromDeducedType(T)) return false; } while (false); do { if (!getDerived().VisitAutoType(T)) return false; } while (false); return true; } bool VisitAutoType(AutoType *T) { return true; }
bool WalkUpFromDeducedTemplateSpecializationType(DeducedTemplateSpecializationType *T) { do { if (!getDerived().WalkUpFromDeducedType(T)) return false; } while (false); do { if (!getDerived().VisitDeducedTemplateSpecializationType(T)) return false; } while (false); return true; } bool VisitDeducedTemplateSpecializationType(DeducedTemplateSpecializationType *T) { return true; }
bool WalkUpFromDependentAddressSpaceType(DependentAddressSpaceType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitDependentAddressSpaceType(T)) return false; } while (false); return true; } bool VisitDependentAddressSpaceType(DependentAddressSpaceType *T) { return true; }
bool WalkUpFromDependentExtIntType(DependentExtIntType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitDependentExtIntType(T)) return false; } while (false); return true; } bool VisitDependentExtIntType(DependentExtIntType *T) { return true; }
bool WalkUpFromDependentNameType(DependentNameType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitDependentNameType(T)) return false; } while (false); return true; } bool VisitDependentNameType(DependentNameType *T) { return true; }
bool WalkUpFromDependentSizedExtVectorType(DependentSizedExtVectorType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitDependentSizedExtVectorType(T)) return false; } while (false); return true; } bool VisitDependentSizedExtVectorType(DependentSizedExtVectorType *T) { return true; }
bool WalkUpFromDependentTemplateSpecializationType(DependentTemplateSpecializationType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitDependentTemplateSpecializationType(T)) return false; } while (false); return true; } bool VisitDependentTemplateSpecializationType(DependentTemplateSpecializationType *T) { return true; }
bool WalkUpFromDependentVectorType(DependentVectorType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitDependentVectorType(T)) return false; } while (false); return true; } bool VisitDependentVectorType(DependentVectorType *T) { return true; }
bool WalkUpFromElaboratedType(ElaboratedType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitElaboratedType(T)) return false; } while (false); return true; } bool VisitElaboratedType(ElaboratedType *T) { return true; }
bool WalkUpFromExtIntType(ExtIntType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitExtIntType(T)) return false; } while (false); return true; } bool VisitExtIntType(ExtIntType *T) { return true; }
bool WalkUpFromFunctionType(FunctionType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitFunctionType(T)) return false; } while (false); return true; } bool VisitFunctionType(FunctionType *T) { return true; }
bool WalkUpFromFunctionNoProtoType(FunctionNoProtoType *T) { do { if (!getDerived().WalkUpFromFunctionType(T)) return false; } while (false); do { if (!getDerived().VisitFunctionNoProtoType(T)) return false; } while (false); return true; } bool VisitFunctionNoProtoType(FunctionNoProtoType *T) { return true; }
bool WalkUpFromFunctionProtoType(FunctionProtoType *T) { do { if (!getDerived().WalkUpFromFunctionType(T)) return false; } while (false); do { if (!getDerived().VisitFunctionProtoType(T)) return false; } while (false); return true; } bool VisitFunctionProtoType(FunctionProtoType *T) { return true; }
bool WalkUpFromInjectedClassNameType(InjectedClassNameType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitInjectedClassNameType(T)) return false; } while (false); return true; } bool VisitInjectedClassNameType(InjectedClassNameType *T) { return true; }
bool WalkUpFromMacroQualifiedType(MacroQualifiedType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitMacroQualifiedType(T)) return false; } while (false); return true; } bool VisitMacroQualifiedType(MacroQualifiedType *T) { return true; }
bool WalkUpFromMatrixType(MatrixType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitMatrixType(T)) return false; } while (false); return true; } bool VisitMatrixType(MatrixType *T) { return true; }
bool WalkUpFromConstantMatrixType(ConstantMatrixType *T) { do { if (!getDerived().WalkUpFromMatrixType(T)) return false; } while (false); do { if (!getDerived().VisitConstantMatrixType(T)) return false; } while (false); return true; } bool VisitConstantMatrixType(ConstantMatrixType *T) { return true; }
bool WalkUpFromDependentSizedMatrixType(DependentSizedMatrixType *T) { do { if (!getDerived().WalkUpFromMatrixType(T)) return false; } while (false); do { if (!getDerived().VisitDependentSizedMatrixType(T)) return false; } while (false); return true; } bool VisitDependentSizedMatrixType(DependentSizedMatrixType *T) { return true; }
bool WalkUpFromMemberPointerType(MemberPointerType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitMemberPointerType(T)) return false; } while (false); return true; } bool VisitMemberPointerType(MemberPointerType *T) { return true; }
bool WalkUpFromObjCObjectPointerType(ObjCObjectPointerType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitObjCObjectPointerType(T)) return false; } while (false); return true; } bool VisitObjCObjectPointerType(ObjCObjectPointerType *T) { return true; }
bool WalkUpFromObjCObjectType(ObjCObjectType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitObjCObjectType(T)) return false; } while (false); return true; } bool VisitObjCObjectType(ObjCObjectType *T) { return true; }
bool WalkUpFromObjCInterfaceType(ObjCInterfaceType *T) { do { if (!getDerived().WalkUpFromObjCObjectType(T)) return false; } while (false); do { if (!getDerived().VisitObjCInterfaceType(T)) return false; } while (false); return true; } bool VisitObjCInterfaceType(ObjCInterfaceType *T) { return true; }
bool WalkUpFromObjCTypeParamType(ObjCTypeParamType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitObjCTypeParamType(T)) return false; } while (false); return true; } bool VisitObjCTypeParamType(ObjCTypeParamType *T) { return true; }
bool WalkUpFromPackExpansionType(PackExpansionType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitPackExpansionType(T)) return false; } while (false); return true; } bool VisitPackExpansionType(PackExpansionType *T) { return true; }
bool WalkUpFromParenType(ParenType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitParenType(T)) return false; } while (false); return true; } bool VisitParenType(ParenType *T) { return true; }
bool WalkUpFromPipeType(PipeType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitPipeType(T)) return false; } while (false); return true; } bool VisitPipeType(PipeType *T) { return true; }
bool WalkUpFromPointerType(PointerType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitPointerType(T)) return false; } while (false); return true; } bool VisitPointerType(PointerType *T) { return true; }
bool WalkUpFromReferenceType(ReferenceType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitReferenceType(T)) return false; } while (false); return true; } bool VisitReferenceType(ReferenceType *T) { return true; }
bool WalkUpFromLValueReferenceType(LValueReferenceType *T) { do { if (!getDerived().WalkUpFromReferenceType(T)) return false; } while (false); do { if (!getDerived().VisitLValueReferenceType(T)) return false; } while (false); return true; } bool VisitLValueReferenceType(LValueReferenceType *T) { return true; }
bool WalkUpFromRValueReferenceType(RValueReferenceType *T) { do { if (!getDerived().WalkUpFromReferenceType(T)) return false; } while (false); do { if (!getDerived().VisitRValueReferenceType(T)) return false; } while (false); return true; } bool VisitRValueReferenceType(RValueReferenceType *T) { return true; }
bool WalkUpFromSubstTemplateTypeParmPackType(SubstTemplateTypeParmPackType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitSubstTemplateTypeParmPackType(T)) return false; } while (false); return true; } bool VisitSubstTemplateTypeParmPackType(SubstTemplateTypeParmPackType *T) { return true; }
bool WalkUpFromSubstTemplateTypeParmType(SubstTemplateTypeParmType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitSubstTemplateTypeParmType(T)) return false; } while (false); return true; } bool VisitSubstTemplateTypeParmType(SubstTemplateTypeParmType *T) { return true; }
bool WalkUpFromTagType(TagType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitTagType(T)) return false; } while (false); return true; } bool VisitTagType(TagType *T) { return true; }
bool WalkUpFromEnumType(EnumType *T) { do { if (!getDerived().WalkUpFromTagType(T)) return false; } while (false); do { if (!getDerived().VisitEnumType(T)) return false; } while (false); return true; } bool VisitEnumType(EnumType *T) { return true; }
bool WalkUpFromRecordType(RecordType *T) { do { if (!getDerived().WalkUpFromTagType(T)) return false; } while (false); do { if (!getDerived().VisitRecordType(T)) return false; } while (false); return true; } bool VisitRecordType(RecordType *T) { return true; }
bool WalkUpFromTemplateSpecializationType(TemplateSpecializationType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitTemplateSpecializationType(T)) return false; } while (false); return true; } bool VisitTemplateSpecializationType(TemplateSpecializationType *T) { return true; }
bool WalkUpFromTemplateTypeParmType(TemplateTypeParmType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitTemplateTypeParmType(T)) return false; } while (false); return true; } bool VisitTemplateTypeParmType(TemplateTypeParmType *T) { return true; }
bool WalkUpFromTypeOfExprType(TypeOfExprType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitTypeOfExprType(T)) return false; } while (false); return true; } bool VisitTypeOfExprType(TypeOfExprType *T) { return true; }
bool WalkUpFromTypeOfType(TypeOfType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitTypeOfType(T)) return false; } while (false); return true; } bool VisitTypeOfType(TypeOfType *T) { return true; }
bool WalkUpFromTypedefType(TypedefType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitTypedefType(T)) return false; } while (false); return true; } bool VisitTypedefType(TypedefType *T) { return true; }
bool WalkUpFromUnaryTransformType(UnaryTransformType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitUnaryTransformType(T)) return false; } while (false); return true; } bool VisitUnaryTransformType(UnaryTransformType *T) { return true; }
bool WalkUpFromUnresolvedUsingType(UnresolvedUsingType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitUnresolvedUsingType(T)) return false; } while (false); return true; } bool VisitUnresolvedUsingType(UnresolvedUsingType *T) { return true; }
bool WalkUpFromVectorType(VectorType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitVectorType(T)) return false; } while (false); return true; } bool VisitVectorType(VectorType *T) { return true; }
bool WalkUpFromExtVectorType(ExtVectorType *T) { do { if (!getDerived().WalkUpFromVectorType(T)) return false; } while (false); do { if (!getDerived().VisitExtVectorType(T)) return false; } while (false); return true; } bool VisitExtVectorType(ExtVectorType *T) { return true; }
bool TraverseQualifiedTypeLoc(QualifiedTypeLoc TL);
bool TraverseAdjustedTypeLoc(AdjustedTypeLoc TL);
bool TraverseDecayedTypeLoc(DecayedTypeLoc TL);
bool TraverseConstantArrayTypeLoc(ConstantArrayTypeLoc TL);
bool TraverseDependentSizedArrayTypeLoc(DependentSizedArrayTypeLoc TL);
bool TraverseIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL);
bool TraverseVariableArrayTypeLoc(VariableArrayTypeLoc TL);
bool TraverseAtomicTypeLoc(AtomicTypeLoc TL);
bool TraverseAttributedTypeLoc(AttributedTypeLoc TL);
bool TraverseBlockPointerTypeLoc(BlockPointerTypeLoc TL);
bool TraverseBuiltinTypeLoc(BuiltinTypeLoc TL);
bool TraverseComplexTypeLoc(ComplexTypeLoc TL);
bool TraverseDecltypeTypeLoc(DecltypeTypeLoc TL);
bool TraverseAutoTypeLoc(AutoTypeLoc TL);
bool TraverseDeducedTemplateSpecializationTypeLoc(DeducedTemplateSpecializationTypeLoc TL);
bool TraverseDependentAddressSpaceTypeLoc(DependentAddressSpaceTypeLoc TL);
bool TraverseDependentExtIntTypeLoc(DependentExtIntTypeLoc TL);
bool TraverseDependentNameTypeLoc(DependentNameTypeLoc TL);
bool TraverseDependentSizedExtVectorTypeLoc(DependentSizedExtVectorTypeLoc TL);
bool TraverseDependentTemplateSpecializationTypeLoc(DependentTemplateSpecializationTypeLoc TL);
bool TraverseDependentVectorTypeLoc(DependentVectorTypeLoc TL);
bool TraverseElaboratedTypeLoc(ElaboratedTypeLoc TL);
bool TraverseExtIntTypeLoc(ExtIntTypeLoc TL);
bool TraverseFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL);
bool TraverseFunctionProtoTypeLoc(FunctionProtoTypeLoc TL);
bool TraverseInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL);
bool TraverseMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL);
bool TraverseConstantMatrixTypeLoc(ConstantMatrixTypeLoc TL);
bool TraverseDependentSizedMatrixTypeLoc(DependentSizedMatrixTypeLoc TL);
bool TraverseMemberPointerTypeLoc(MemberPointerTypeLoc TL);
bool TraverseObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL);
bool TraverseObjCObjectTypeLoc(ObjCObjectTypeLoc TL);
bool TraverseObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL);
bool TraverseObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL);
bool TraversePackExpansionTypeLoc(PackExpansionTypeLoc TL);
bool TraverseParenTypeLoc(ParenTypeLoc TL);
bool TraversePipeTypeLoc(PipeTypeLoc TL);
bool TraversePointerTypeLoc(PointerTypeLoc TL);
bool TraverseLValueReferenceTypeLoc(LValueReferenceTypeLoc TL);
bool TraverseRValueReferenceTypeLoc(RValueReferenceTypeLoc TL);
bool TraverseSubstTemplateTypeParmPackTypeLoc(SubstTemplateTypeParmPackTypeLoc TL);
bool TraverseSubstTemplateTypeParmTypeLoc(SubstTemplateTypeParmTypeLoc TL);
bool TraverseEnumTypeLoc(EnumTypeLoc TL);
bool TraverseRecordTypeLoc(RecordTypeLoc TL);
bool TraverseTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL);
bool TraverseTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL);
bool TraverseTypeOfExprTypeLoc(TypeOfExprTypeLoc TL);
bool TraverseTypeOfTypeLoc(TypeOfTypeLoc TL);
bool TraverseTypedefTypeLoc(TypedefTypeLoc TL);
bool TraverseUnaryTransformTypeLoc(UnaryTransformTypeLoc TL);
bool TraverseUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL);
bool TraverseVectorTypeLoc(VectorTypeLoc TL);
bool TraverseExtVectorTypeLoc(ExtVectorTypeLoc TL);
  bool WalkUpFromTypeLoc(TypeLoc TL) { return getDerived().VisitTypeLoc(TL); }
  bool VisitTypeLoc(TypeLoc TL) { return true; }
  bool WalkUpFromQualifiedTypeLoc(QualifiedTypeLoc TL) {
    return getDerived().VisitUnqualTypeLoc(TL.getUnqualifiedLoc());
  }
  bool VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { return true; }
  bool WalkUpFromUnqualTypeLoc(UnqualTypeLoc TL) {
    return getDerived().VisitUnqualTypeLoc(TL.getUnqualifiedLoc());
  }
  bool VisitUnqualTypeLoc(UnqualTypeLoc TL) { return true; }
bool WalkUpFromAdjustedTypeLoc(AdjustedTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitAdjustedTypeLoc(TL)) return false; } while (false); return true; } bool VisitAdjustedTypeLoc(AdjustedTypeLoc TL) { return true; }
bool WalkUpFromDecayedTypeLoc(DecayedTypeLoc TL) { do { if (!getDerived().WalkUpFromAdjustedTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDecayedTypeLoc(TL)) return false; } while (false); return true; } bool VisitDecayedTypeLoc(DecayedTypeLoc TL) { return true; }
bool WalkUpFromArrayTypeLoc(ArrayTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitArrayTypeLoc(TL)) return false; } while (false); return true; } bool VisitArrayTypeLoc(ArrayTypeLoc TL) { return true; }
bool WalkUpFromConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { do { if (!getDerived().WalkUpFromArrayTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitConstantArrayTypeLoc(TL)) return false; } while (false); return true; } bool VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { return true; }
bool WalkUpFromDependentSizedArrayTypeLoc(DependentSizedArrayTypeLoc TL) { do { if (!getDerived().WalkUpFromArrayTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDependentSizedArrayTypeLoc(TL)) return false; } while (false); return true; } bool VisitDependentSizedArrayTypeLoc(DependentSizedArrayTypeLoc TL) { return true; }
bool WalkUpFromIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { do { if (!getDerived().WalkUpFromArrayTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitIncompleteArrayTypeLoc(TL)) return false; } while (false); return true; } bool VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { return true; }
bool WalkUpFromVariableArrayTypeLoc(VariableArrayTypeLoc TL) { do { if (!getDerived().WalkUpFromArrayTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitVariableArrayTypeLoc(TL)) return false; } while (false); return true; } bool VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { return true; }
bool WalkUpFromAtomicTypeLoc(AtomicTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitAtomicTypeLoc(TL)) return false; } while (false); return true; } bool VisitAtomicTypeLoc(AtomicTypeLoc TL) { return true; }
bool WalkUpFromAttributedTypeLoc(AttributedTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitAttributedTypeLoc(TL)) return false; } while (false); return true; } bool VisitAttributedTypeLoc(AttributedTypeLoc TL) { return true; }
bool WalkUpFromBlockPointerTypeLoc(BlockPointerTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitBlockPointerTypeLoc(TL)) return false; } while (false); return true; } bool VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { return true; }
bool WalkUpFromBuiltinTypeLoc(BuiltinTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitBuiltinTypeLoc(TL)) return false; } while (false); return true; } bool VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { return true; }
bool WalkUpFromComplexTypeLoc(ComplexTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitComplexTypeLoc(TL)) return false; } while (false); return true; } bool VisitComplexTypeLoc(ComplexTypeLoc TL) { return true; }
bool WalkUpFromDecltypeTypeLoc(DecltypeTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDecltypeTypeLoc(TL)) return false; } while (false); return true; } bool VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { return true; }
bool WalkUpFromDeducedTypeLoc(DeducedTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDeducedTypeLoc(TL)) return false; } while (false); return true; } bool VisitDeducedTypeLoc(DeducedTypeLoc TL) { return true; }
bool WalkUpFromAutoTypeLoc(AutoTypeLoc TL) { do { if (!getDerived().WalkUpFromDeducedTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitAutoTypeLoc(TL)) return false; } while (false); return true; } bool VisitAutoTypeLoc(AutoTypeLoc TL) { return true; }
bool WalkUpFromDeducedTemplateSpecializationTypeLoc(DeducedTemplateSpecializationTypeLoc TL) { do { if (!getDerived().WalkUpFromDeducedTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDeducedTemplateSpecializationTypeLoc(TL)) return false; } while (false); return true; } bool VisitDeducedTemplateSpecializationTypeLoc(DeducedTemplateSpecializationTypeLoc TL) { return true; }
bool WalkUpFromDependentAddressSpaceTypeLoc(DependentAddressSpaceTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDependentAddressSpaceTypeLoc(TL)) return false; } while (false); return true; } bool VisitDependentAddressSpaceTypeLoc(DependentAddressSpaceTypeLoc TL) { return true; }
bool WalkUpFromDependentExtIntTypeLoc(DependentExtIntTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDependentExtIntTypeLoc(TL)) return false; } while (false); return true; } bool VisitDependentExtIntTypeLoc(DependentExtIntTypeLoc TL) { return true; }
bool WalkUpFromDependentNameTypeLoc(DependentNameTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDependentNameTypeLoc(TL)) return false; } while (false); return true; } bool VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { return true; }
bool WalkUpFromDependentSizedExtVectorTypeLoc(DependentSizedExtVectorTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDependentSizedExtVectorTypeLoc(TL)) return false; } while (false); return true; } bool VisitDependentSizedExtVectorTypeLoc(DependentSizedExtVectorTypeLoc TL) { return true; }
bool WalkUpFromDependentTemplateSpecializationTypeLoc(DependentTemplateSpecializationTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDependentTemplateSpecializationTypeLoc(TL)) return false; } while (false); return true; } bool VisitDependentTemplateSpecializationTypeLoc(DependentTemplateSpecializationTypeLoc TL) { return true; }
bool WalkUpFromDependentVectorTypeLoc(DependentVectorTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDependentVectorTypeLoc(TL)) return false; } while (false); return true; } bool VisitDependentVectorTypeLoc(DependentVectorTypeLoc TL) { return true; }
bool WalkUpFromElaboratedTypeLoc(ElaboratedTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitElaboratedTypeLoc(TL)) return false; } while (false); return true; } bool VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { return true; }
bool WalkUpFromExtIntTypeLoc(ExtIntTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitExtIntTypeLoc(TL)) return false; } while (false); return true; } bool VisitExtIntTypeLoc(ExtIntTypeLoc TL) { return true; }
bool WalkUpFromFunctionTypeLoc(FunctionTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitFunctionTypeLoc(TL)) return false; } while (false); return true; } bool VisitFunctionTypeLoc(FunctionTypeLoc TL) { return true; }
bool WalkUpFromFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { do { if (!getDerived().WalkUpFromFunctionTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitFunctionNoProtoTypeLoc(TL)) return false; } while (false); return true; } bool VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { return true; }
bool WalkUpFromFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { do { if (!getDerived().WalkUpFromFunctionTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitFunctionProtoTypeLoc(TL)) return false; } while (false); return true; } bool VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { return true; }
bool WalkUpFromInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitInjectedClassNameTypeLoc(TL)) return false; } while (false); return true; } bool VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { return true; }
bool WalkUpFromMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitMacroQualifiedTypeLoc(TL)) return false; } while (false); return true; } bool VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) { return true; }
bool WalkUpFromMatrixTypeLoc(MatrixTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitMatrixTypeLoc(TL)) return false; } while (false); return true; } bool VisitMatrixTypeLoc(MatrixTypeLoc TL) { return true; }
bool WalkUpFromConstantMatrixTypeLoc(ConstantMatrixTypeLoc TL) { do { if (!getDerived().WalkUpFromMatrixTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitConstantMatrixTypeLoc(TL)) return false; } while (false); return true; } bool VisitConstantMatrixTypeLoc(ConstantMatrixTypeLoc TL) { return true; }
bool WalkUpFromDependentSizedMatrixTypeLoc(DependentSizedMatrixTypeLoc TL) { do { if (!getDerived().WalkUpFromMatrixTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDependentSizedMatrixTypeLoc(TL)) return false; } while (false); return true; } bool VisitDependentSizedMatrixTypeLoc(DependentSizedMatrixTypeLoc TL) { return true; }
bool WalkUpFromMemberPointerTypeLoc(MemberPointerTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitMemberPointerTypeLoc(TL)) return false; } while (false); return true; } bool VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { return true; }
bool WalkUpFromObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitObjCObjectPointerTypeLoc(TL)) return false; } while (false); return true; } bool VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { return true; }
bool WalkUpFromObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitObjCObjectTypeLoc(TL)) return false; } while (false); return true; } bool VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { return true; }
bool WalkUpFromObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { do { if (!getDerived().WalkUpFromObjCObjectTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitObjCInterfaceTypeLoc(TL)) return false; } while (false); return true; } bool VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { return true; }
bool WalkUpFromObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitObjCTypeParamTypeLoc(TL)) return false; } while (false); return true; } bool VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) { return true; }
bool WalkUpFromPackExpansionTypeLoc(PackExpansionTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitPackExpansionTypeLoc(TL)) return false; } while (false); return true; } bool VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { return true; }
bool WalkUpFromParenTypeLoc(ParenTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitParenTypeLoc(TL)) return false; } while (false); return true; } bool VisitParenTypeLoc(ParenTypeLoc TL) { return true; }
bool WalkUpFromPipeTypeLoc(PipeTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitPipeTypeLoc(TL)) return false; } while (false); return true; } bool VisitPipeTypeLoc(PipeTypeLoc TL) { return true; }
bool WalkUpFromPointerTypeLoc(PointerTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitPointerTypeLoc(TL)) return false; } while (false); return true; } bool VisitPointerTypeLoc(PointerTypeLoc TL) { return true; }
bool WalkUpFromReferenceTypeLoc(ReferenceTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitReferenceTypeLoc(TL)) return false; } while (false); return true; } bool VisitReferenceTypeLoc(ReferenceTypeLoc TL) { return true; }
bool WalkUpFromLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { do { if (!getDerived().WalkUpFromReferenceTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitLValueReferenceTypeLoc(TL)) return false; } while (false); return true; } bool VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { return true; }
bool WalkUpFromRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { do { if (!getDerived().WalkUpFromReferenceTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitRValueReferenceTypeLoc(TL)) return false; } while (false); return true; } bool VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { return true; }
bool WalkUpFromSubstTemplateTypeParmPackTypeLoc(SubstTemplateTypeParmPackTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitSubstTemplateTypeParmPackTypeLoc(TL)) return false; } while (false); return true; } bool VisitSubstTemplateTypeParmPackTypeLoc(SubstTemplateTypeParmPackTypeLoc TL) { return true; }
bool WalkUpFromSubstTemplateTypeParmTypeLoc(SubstTemplateTypeParmTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitSubstTemplateTypeParmTypeLoc(TL)) return false; } while (false); return true; } bool VisitSubstTemplateTypeParmTypeLoc(SubstTemplateTypeParmTypeLoc TL) { return true; }
bool WalkUpFromTagTypeLoc(TagTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitTagTypeLoc(TL)) return false; } while (false); return true; } bool VisitTagTypeLoc(TagTypeLoc TL) { return true; }
bool WalkUpFromEnumTypeLoc(EnumTypeLoc TL) { do { if (!getDerived().WalkUpFromTagTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitEnumTypeLoc(TL)) return false; } while (false); return true; } bool VisitEnumTypeLoc(EnumTypeLoc TL) { return true; }
bool WalkUpFromRecordTypeLoc(RecordTypeLoc TL) { do { if (!getDerived().WalkUpFromTagTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitRecordTypeLoc(TL)) return false; } while (false); return true; } bool VisitRecordTypeLoc(RecordTypeLoc TL) { return true; }
bool WalkUpFromTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitTemplateSpecializationTypeLoc(TL)) return false; } while (false); return true; } bool VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) { return true; }
bool WalkUpFromTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitTemplateTypeParmTypeLoc(TL)) return false; } while (false); return true; } bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { return true; }
bool WalkUpFromTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitTypeOfExprTypeLoc(TL)) return false; } while (false); return true; } bool VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { return true; }
bool WalkUpFromTypeOfTypeLoc(TypeOfTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitTypeOfTypeLoc(TL)) return false; } while (false); return true; } bool VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { return true; }
bool WalkUpFromTypedefTypeLoc(TypedefTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitTypedefTypeLoc(TL)) return false; } while (false); return true; } bool VisitTypedefTypeLoc(TypedefTypeLoc TL) { return true; }
bool WalkUpFromUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitUnaryTransformTypeLoc(TL)) return false; } while (false); return true; } bool VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { return true; }
bool WalkUpFromUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitUnresolvedUsingTypeLoc(TL)) return false; } while (false); return true; } bool VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { return true; }
bool WalkUpFromVectorTypeLoc(VectorTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitVectorTypeLoc(TL)) return false; } while (false); return true; } bool VisitVectorTypeLoc(VectorTypeLoc TL) { return true; }
bool WalkUpFromExtVectorTypeLoc(ExtVectorTypeLoc TL) { do { if (!getDerived().WalkUpFromVectorTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitExtVectorTypeLoc(TL)) return false; } while (false); return true; } bool VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { return true; }
bool TraverseAccessSpecDecl(AccessSpecDecl *D);
bool TraverseBlockDecl(BlockDecl *D);
bool TraverseCapturedDecl(CapturedDecl *D);
bool TraverseClassScopeFunctionSpecializationDecl(ClassScopeFunctionSpecializationDecl *D);
bool TraverseEmptyDecl(EmptyDecl *D);
bool TraverseExportDecl(ExportDecl *D);
bool TraverseExternCContextDecl(ExternCContextDecl *D);
bool TraverseFileScopeAsmDecl(FileScopeAsmDecl *D);
bool TraverseFriendDecl(FriendDecl *D);
bool TraverseFriendTemplateDecl(FriendTemplateDecl *D);
bool TraverseImportDecl(ImportDecl *D);
bool TraverseLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D);
bool TraverseLinkageSpecDecl(LinkageSpecDecl *D);
bool TraverseUsingDecl(UsingDecl *D);
bool TraverseUsingEnumDecl(UsingEnumDecl *D);
bool TraverseLabelDecl(LabelDecl *D);
bool TraverseNamespaceDecl(NamespaceDecl *D);
bool TraverseNamespaceAliasDecl(NamespaceAliasDecl *D);
bool TraverseObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
bool TraverseObjCCategoryDecl(ObjCCategoryDecl *D);
bool TraverseObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
bool TraverseObjCImplementationDecl(ObjCImplementationDecl *D);
bool TraverseObjCInterfaceDecl(ObjCInterfaceDecl *D);
bool TraverseObjCProtocolDecl(ObjCProtocolDecl *D);
bool TraverseObjCMethodDecl(ObjCMethodDecl *D);
bool TraverseObjCPropertyDecl(ObjCPropertyDecl *D);
bool TraverseBuiltinTemplateDecl(BuiltinTemplateDecl *D);
bool TraverseConceptDecl(ConceptDecl *D);
bool TraverseClassTemplateDecl(ClassTemplateDecl *D);
bool TraverseFunctionTemplateDecl(FunctionTemplateDecl *D);
bool TraverseTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
bool TraverseVarTemplateDecl(VarTemplateDecl *D);
bool TraverseTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
bool TraverseEnumDecl(EnumDecl *D);
bool TraverseRecordDecl(RecordDecl *D);
bool TraverseCXXRecordDecl(CXXRecordDecl *D);
bool TraverseClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D);
bool TraverseClassTemplatePartialSpecializationDecl(ClassTemplatePartialSpecializationDecl *D);
bool TraverseTemplateTypeParmDecl(TemplateTypeParmDecl *D);
bool TraverseObjCTypeParamDecl(ObjCTypeParamDecl *D);
bool TraverseTypeAliasDecl(TypeAliasDecl *D);
bool TraverseTypedefDecl(TypedefDecl *D);
bool TraverseUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
bool TraverseUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D);
bool TraverseUsingDirectiveDecl(UsingDirectiveDecl *D);
bool TraverseUsingPackDecl(UsingPackDecl *D);
bool TraverseUsingShadowDecl(UsingShadowDecl *D);
bool TraverseConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D);
bool TraverseBindingDecl(BindingDecl *D);
bool TraverseFieldDecl(FieldDecl *D);
bool TraverseObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
bool TraverseObjCIvarDecl(ObjCIvarDecl *D);
bool TraverseFunctionDecl(FunctionDecl *D);
bool TraverseCXXDeductionGuideDecl(CXXDeductionGuideDecl *D);
bool TraverseCXXMethodDecl(CXXMethodDecl *D);
bool TraverseCXXConstructorDecl(CXXConstructorDecl *D);
bool TraverseCXXConversionDecl(CXXConversionDecl *D);
bool TraverseCXXDestructorDecl(CXXDestructorDecl *D);
bool TraverseMSPropertyDecl(MSPropertyDecl *D);
bool TraverseNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
bool TraverseVarDecl(VarDecl *D);
bool TraverseDecompositionDecl(DecompositionDecl *D);
bool TraverseImplicitParamDecl(ImplicitParamDecl *D);
bool TraverseOMPCapturedExprDecl(OMPCapturedExprDecl *D);
bool TraverseParmVarDecl(ParmVarDecl *D);
bool TraverseVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
bool TraverseVarTemplatePartialSpecializationDecl(VarTemplatePartialSpecializationDecl *D);
bool TraverseEnumConstantDecl(EnumConstantDecl *D);
bool TraverseIndirectFieldDecl(IndirectFieldDecl *D);
bool TraverseMSGuidDecl(MSGuidDecl *D);
bool TraverseOMPDeclareMapperDecl(OMPDeclareMapperDecl *D);
bool TraverseOMPDeclareReductionDecl(OMPDeclareReductionDecl *D);
bool TraverseTemplateParamObjectDecl(TemplateParamObjectDecl *D);
bool TraverseUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
bool TraverseOMPAllocateDecl(OMPAllocateDecl *D);
bool TraverseOMPRequiresDecl(OMPRequiresDecl *D);
bool TraverseOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
bool TraverseObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
bool TraversePragmaCommentDecl(PragmaCommentDecl *D);
bool TraversePragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D);
bool TraverseRequiresExprBodyDecl(RequiresExprBodyDecl *D);
bool TraverseStaticAssertDecl(StaticAssertDecl *D);
bool TraverseTranslationUnitDecl(TranslationUnitDecl *D);
  bool WalkUpFromDecl(Decl *D) { return getDerived().VisitDecl(D); }
  bool VisitDecl(Decl *D) { return true; }
bool WalkUpFromAccessSpecDecl(AccessSpecDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitAccessSpecDecl(D)) return false; } while (false); return true; } bool VisitAccessSpecDecl(AccessSpecDecl *D) { return true; }
bool WalkUpFromBlockDecl(BlockDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitBlockDecl(D)) return false; } while (false); return true; } bool VisitBlockDecl(BlockDecl *D) { return true; }
bool WalkUpFromCapturedDecl(CapturedDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitCapturedDecl(D)) return false; } while (false); return true; } bool VisitCapturedDecl(CapturedDecl *D) { return true; }
bool WalkUpFromClassScopeFunctionSpecializationDecl(ClassScopeFunctionSpecializationDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitClassScopeFunctionSpecializationDecl(D)) return false; } while (false); return true; } bool VisitClassScopeFunctionSpecializationDecl(ClassScopeFunctionSpecializationDecl *D) { return true; }
bool WalkUpFromEmptyDecl(EmptyDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitEmptyDecl(D)) return false; } while (false); return true; } bool VisitEmptyDecl(EmptyDecl *D) { return true; }
bool WalkUpFromExportDecl(ExportDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitExportDecl(D)) return false; } while (false); return true; } bool VisitExportDecl(ExportDecl *D) { return true; }
bool WalkUpFromExternCContextDecl(ExternCContextDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitExternCContextDecl(D)) return false; } while (false); return true; } bool VisitExternCContextDecl(ExternCContextDecl *D) { return true; }
bool WalkUpFromFileScopeAsmDecl(FileScopeAsmDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitFileScopeAsmDecl(D)) return false; } while (false); return true; } bool VisitFileScopeAsmDecl(FileScopeAsmDecl *D) { return true; }
bool WalkUpFromFriendDecl(FriendDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitFriendDecl(D)) return false; } while (false); return true; } bool VisitFriendDecl(FriendDecl *D) { return true; }
bool WalkUpFromFriendTemplateDecl(FriendTemplateDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitFriendTemplateDecl(D)) return false; } while (false); return true; } bool VisitFriendTemplateDecl(FriendTemplateDecl *D) { return true; }
bool WalkUpFromImportDecl(ImportDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitImportDecl(D)) return false; } while (false); return true; } bool VisitImportDecl(ImportDecl *D) { return true; }
bool WalkUpFromLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitLifetimeExtendedTemporaryDecl(D)) return false; } while (false); return true; } bool VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D) { return true; }
bool WalkUpFromLinkageSpecDecl(LinkageSpecDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitLinkageSpecDecl(D)) return false; } while (false); return true; } bool VisitLinkageSpecDecl(LinkageSpecDecl *D) { return true; }
bool WalkUpFromNamedDecl(NamedDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitNamedDecl(D)) return false; } while (false); return true; } bool VisitNamedDecl(NamedDecl *D) { return true; }
bool WalkUpFromBaseUsingDecl(BaseUsingDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitBaseUsingDecl(D)) return false; } while (false); return true; } bool VisitBaseUsingDecl(BaseUsingDecl *D) { return true; }
bool WalkUpFromUsingDecl(UsingDecl *D) { do { if (!getDerived().WalkUpFromBaseUsingDecl(D)) return false; } while (false); do { if (!getDerived().VisitUsingDecl(D)) return false; } while (false); return true; } bool VisitUsingDecl(UsingDecl *D) { return true; }
bool WalkUpFromUsingEnumDecl(UsingEnumDecl *D) { do { if (!getDerived().WalkUpFromBaseUsingDecl(D)) return false; } while (false); do { if (!getDerived().VisitUsingEnumDecl(D)) return false; } while (false); return true; } bool VisitUsingEnumDecl(UsingEnumDecl *D) { return true; }
bool WalkUpFromLabelDecl(LabelDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitLabelDecl(D)) return false; } while (false); return true; } bool VisitLabelDecl(LabelDecl *D) { return true; }
bool WalkUpFromNamespaceDecl(NamespaceDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitNamespaceDecl(D)) return false; } while (false); return true; } bool VisitNamespaceDecl(NamespaceDecl *D) { return true; }
bool WalkUpFromNamespaceAliasDecl(NamespaceAliasDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitNamespaceAliasDecl(D)) return false; } while (false); return true; } bool VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { return true; }
bool WalkUpFromObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCCompatibleAliasDecl(D)) return false; } while (false); return true; } bool VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) { return true; }
bool WalkUpFromObjCContainerDecl(ObjCContainerDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCContainerDecl(D)) return false; } while (false); return true; } bool VisitObjCContainerDecl(ObjCContainerDecl *D) { return true; }
bool WalkUpFromObjCCategoryDecl(ObjCCategoryDecl *D) { do { if (!getDerived().WalkUpFromObjCContainerDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCCategoryDecl(D)) return false; } while (false); return true; } bool VisitObjCCategoryDecl(ObjCCategoryDecl *D) { return true; }
bool WalkUpFromObjCImplDecl(ObjCImplDecl *D) { do { if (!getDerived().WalkUpFromObjCContainerDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCImplDecl(D)) return false; } while (false); return true; } bool VisitObjCImplDecl(ObjCImplDecl *D) { return true; }
bool WalkUpFromObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { do { if (!getDerived().WalkUpFromObjCImplDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCCategoryImplDecl(D)) return false; } while (false); return true; } bool VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { return true; }
bool WalkUpFromObjCImplementationDecl(ObjCImplementationDecl *D) { do { if (!getDerived().WalkUpFromObjCImplDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCImplementationDecl(D)) return false; } while (false); return true; } bool VisitObjCImplementationDecl(ObjCImplementationDecl *D) { return true; }
bool WalkUpFromObjCInterfaceDecl(ObjCInterfaceDecl *D) { do { if (!getDerived().WalkUpFromObjCContainerDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCInterfaceDecl(D)) return false; } while (false); return true; } bool VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { return true; }
bool WalkUpFromObjCProtocolDecl(ObjCProtocolDecl *D) { do { if (!getDerived().WalkUpFromObjCContainerDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCProtocolDecl(D)) return false; } while (false); return true; } bool VisitObjCProtocolDecl(ObjCProtocolDecl *D) { return true; }
bool WalkUpFromObjCMethodDecl(ObjCMethodDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCMethodDecl(D)) return false; } while (false); return true; } bool VisitObjCMethodDecl(ObjCMethodDecl *D) { return true; }
bool WalkUpFromObjCPropertyDecl(ObjCPropertyDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCPropertyDecl(D)) return false; } while (false); return true; } bool VisitObjCPropertyDecl(ObjCPropertyDecl *D) { return true; }
bool WalkUpFromTemplateDecl(TemplateDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitTemplateDecl(D)) return false; } while (false); return true; } bool VisitTemplateDecl(TemplateDecl *D) { return true; }
bool WalkUpFromBuiltinTemplateDecl(BuiltinTemplateDecl *D) { do { if (!getDerived().WalkUpFromTemplateDecl(D)) return false; } while (false); do { if (!getDerived().VisitBuiltinTemplateDecl(D)) return false; } while (false); return true; } bool VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) { return true; }
bool WalkUpFromConceptDecl(ConceptDecl *D) { do { if (!getDerived().WalkUpFromTemplateDecl(D)) return false; } while (false); do { if (!getDerived().VisitConceptDecl(D)) return false; } while (false); return true; } bool VisitConceptDecl(ConceptDecl *D) { return true; }
bool WalkUpFromRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) { do { if (!getDerived().WalkUpFromTemplateDecl(D)) return false; } while (false); do { if (!getDerived().VisitRedeclarableTemplateDecl(D)) return false; } while (false); return true; } bool VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) { return true; }
bool WalkUpFromClassTemplateDecl(ClassTemplateDecl *D) { do { if (!getDerived().WalkUpFromRedeclarableTemplateDecl(D)) return false; } while (false); do { if (!getDerived().VisitClassTemplateDecl(D)) return false; } while (false); return true; } bool VisitClassTemplateDecl(ClassTemplateDecl *D) { return true; }
bool WalkUpFromFunctionTemplateDecl(FunctionTemplateDecl *D) { do { if (!getDerived().WalkUpFromRedeclarableTemplateDecl(D)) return false; } while (false); do { if (!getDerived().VisitFunctionTemplateDecl(D)) return false; } while (false); return true; } bool VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { return true; }
bool WalkUpFromTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) { do { if (!getDerived().WalkUpFromRedeclarableTemplateDecl(D)) return false; } while (false); do { if (!getDerived().VisitTypeAliasTemplateDecl(D)) return false; } while (false); return true; } bool VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) { return true; }
bool WalkUpFromVarTemplateDecl(VarTemplateDecl *D) { do { if (!getDerived().WalkUpFromRedeclarableTemplateDecl(D)) return false; } while (false); do { if (!getDerived().VisitVarTemplateDecl(D)) return false; } while (false); return true; } bool VisitVarTemplateDecl(VarTemplateDecl *D) { return true; }
bool WalkUpFromTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { do { if (!getDerived().WalkUpFromTemplateDecl(D)) return false; } while (false); do { if (!getDerived().VisitTemplateTemplateParmDecl(D)) return false; } while (false); return true; } bool VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { return true; }
bool WalkUpFromTypeDecl(TypeDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitTypeDecl(D)) return false; } while (false); return true; } bool VisitTypeDecl(TypeDecl *D) { return true; }
bool WalkUpFromTagDecl(TagDecl *D) { do { if (!getDerived().WalkUpFromTypeDecl(D)) return false; } while (false); do { if (!getDerived().VisitTagDecl(D)) return false; } while (false); return true; } bool VisitTagDecl(TagDecl *D) { return true; }
bool WalkUpFromEnumDecl(EnumDecl *D) { do { if (!getDerived().WalkUpFromTagDecl(D)) return false; } while (false); do { if (!getDerived().VisitEnumDecl(D)) return false; } while (false); return true; } bool VisitEnumDecl(EnumDecl *D) { return true; }
bool WalkUpFromRecordDecl(RecordDecl *D) { do { if (!getDerived().WalkUpFromTagDecl(D)) return false; } while (false); do { if (!getDerived().VisitRecordDecl(D)) return false; } while (false); return true; } bool VisitRecordDecl(RecordDecl *D) { return true; }
bool WalkUpFromCXXRecordDecl(CXXRecordDecl *D) { do { if (!getDerived().WalkUpFromRecordDecl(D)) return false; } while (false); do { if (!getDerived().VisitCXXRecordDecl(D)) return false; } while (false); return true; } bool VisitCXXRecordDecl(CXXRecordDecl *D) { return true; }
bool WalkUpFromClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D) { do { if (!getDerived().WalkUpFromCXXRecordDecl(D)) return false; } while (false); do { if (!getDerived().VisitClassTemplateSpecializationDecl(D)) return false; } while (false); return true; } bool VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D) { return true; }
bool WalkUpFromClassTemplatePartialSpecializationDecl(ClassTemplatePartialSpecializationDecl *D) { do { if (!getDerived().WalkUpFromClassTemplateSpecializationDecl(D)) return false; } while (false); do { if (!getDerived().VisitClassTemplatePartialSpecializationDecl(D)) return false; } while (false); return true; } bool VisitClassTemplatePartialSpecializationDecl(ClassTemplatePartialSpecializationDecl *D) { return true; }
bool WalkUpFromTemplateTypeParmDecl(TemplateTypeParmDecl *D) { do { if (!getDerived().WalkUpFromTypeDecl(D)) return false; } while (false); do { if (!getDerived().VisitTemplateTypeParmDecl(D)) return false; } while (false); return true; } bool VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { return true; }
bool WalkUpFromTypedefNameDecl(TypedefNameDecl *D) { do { if (!getDerived().WalkUpFromTypeDecl(D)) return false; } while (false); do { if (!getDerived().VisitTypedefNameDecl(D)) return false; } while (false); return true; } bool VisitTypedefNameDecl(TypedefNameDecl *D) { return true; }
bool WalkUpFromObjCTypeParamDecl(ObjCTypeParamDecl *D) { do { if (!getDerived().WalkUpFromTypedefNameDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCTypeParamDecl(D)) return false; } while (false); return true; } bool VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) { return true; }
bool WalkUpFromTypeAliasDecl(TypeAliasDecl *D) { do { if (!getDerived().WalkUpFromTypedefNameDecl(D)) return false; } while (false); do { if (!getDerived().VisitTypeAliasDecl(D)) return false; } while (false); return true; } bool VisitTypeAliasDecl(TypeAliasDecl *D) { return true; }
bool WalkUpFromTypedefDecl(TypedefDecl *D) { do { if (!getDerived().WalkUpFromTypedefNameDecl(D)) return false; } while (false); do { if (!getDerived().VisitTypedefDecl(D)) return false; } while (false); return true; } bool VisitTypedefDecl(TypedefDecl *D) { return true; }
bool WalkUpFromUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) { do { if (!getDerived().WalkUpFromTypeDecl(D)) return false; } while (false); do { if (!getDerived().VisitUnresolvedUsingTypenameDecl(D)) return false; } while (false); return true; } bool VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) { return true; }
bool WalkUpFromUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitUnresolvedUsingIfExistsDecl(D)) return false; } while (false); return true; } bool VisitUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D) { return true; }
bool WalkUpFromUsingDirectiveDecl(UsingDirectiveDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitUsingDirectiveDecl(D)) return false; } while (false); return true; } bool VisitUsingDirectiveDecl(UsingDirectiveDecl *D) { return true; }
bool WalkUpFromUsingPackDecl(UsingPackDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitUsingPackDecl(D)) return false; } while (false); return true; } bool VisitUsingPackDecl(UsingPackDecl *D) { return true; }
bool WalkUpFromUsingShadowDecl(UsingShadowDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitUsingShadowDecl(D)) return false; } while (false); return true; } bool VisitUsingShadowDecl(UsingShadowDecl *D) { return true; }
bool WalkUpFromConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D) { do { if (!getDerived().WalkUpFromUsingShadowDecl(D)) return false; } while (false); do { if (!getDerived().VisitConstructorUsingShadowDecl(D)) return false; } while (false); return true; } bool VisitConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D) { return true; }
bool WalkUpFromValueDecl(ValueDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitValueDecl(D)) return false; } while (false); return true; } bool VisitValueDecl(ValueDecl *D) { return true; }
bool WalkUpFromBindingDecl(BindingDecl *D) { do { if (!getDerived().WalkUpFromValueDecl(D)) return false; } while (false); do { if (!getDerived().VisitBindingDecl(D)) return false; } while (false); return true; } bool VisitBindingDecl(BindingDecl *D) { return true; }
bool WalkUpFromDeclaratorDecl(DeclaratorDecl *D) { do { if (!getDerived().WalkUpFromValueDecl(D)) return false; } while (false); do { if (!getDerived().VisitDeclaratorDecl(D)) return false; } while (false); return true; } bool VisitDeclaratorDecl(DeclaratorDecl *D) { return true; }
bool WalkUpFromFieldDecl(FieldDecl *D) { do { if (!getDerived().WalkUpFromDeclaratorDecl(D)) return false; } while (false); do { if (!getDerived().VisitFieldDecl(D)) return false; } while (false); return true; } bool VisitFieldDecl(FieldDecl *D) { return true; }
bool WalkUpFromObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) { do { if (!getDerived().WalkUpFromFieldDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCAtDefsFieldDecl(D)) return false; } while (false); return true; } bool VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) { return true; }
bool WalkUpFromObjCIvarDecl(ObjCIvarDecl *D) { do { if (!getDerived().WalkUpFromFieldDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCIvarDecl(D)) return false; } while (false); return true; } bool VisitObjCIvarDecl(ObjCIvarDecl *D) { return true; }
bool WalkUpFromFunctionDecl(FunctionDecl *D) { do { if (!getDerived().WalkUpFromDeclaratorDecl(D)) return false; } while (false); do { if (!getDerived().VisitFunctionDecl(D)) return false; } while (false); return true; } bool VisitFunctionDecl(FunctionDecl *D) { return true; }
bool WalkUpFromCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) { do { if (!getDerived().WalkUpFromFunctionDecl(D)) return false; } while (false); do { if (!getDerived().VisitCXXDeductionGuideDecl(D)) return false; } while (false); return true; } bool VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) { return true; }
bool WalkUpFromCXXMethodDecl(CXXMethodDecl *D) { do { if (!getDerived().WalkUpFromFunctionDecl(D)) return false; } while (false); do { if (!getDerived().VisitCXXMethodDecl(D)) return false; } while (false); return true; } bool VisitCXXMethodDecl(CXXMethodDecl *D) { return true; }
bool WalkUpFromCXXConstructorDecl(CXXConstructorDecl *D) { do { if (!getDerived().WalkUpFromCXXMethodDecl(D)) return false; } while (false); do { if (!getDerived().VisitCXXConstructorDecl(D)) return false; } while (false); return true; } bool VisitCXXConstructorDecl(CXXConstructorDecl *D) { return true; }
bool WalkUpFromCXXConversionDecl(CXXConversionDecl *D) { do { if (!getDerived().WalkUpFromCXXMethodDecl(D)) return false; } while (false); do { if (!getDerived().VisitCXXConversionDecl(D)) return false; } while (false); return true; } bool VisitCXXConversionDecl(CXXConversionDecl *D) { return true; }
bool WalkUpFromCXXDestructorDecl(CXXDestructorDecl *D) { do { if (!getDerived().WalkUpFromCXXMethodDecl(D)) return false; } while (false); do { if (!getDerived().VisitCXXDestructorDecl(D)) return false; } while (false); return true; } bool VisitCXXDestructorDecl(CXXDestructorDecl *D) { return true; }
bool WalkUpFromMSPropertyDecl(MSPropertyDecl *D) { do { if (!getDerived().WalkUpFromDeclaratorDecl(D)) return false; } while (false); do { if (!getDerived().VisitMSPropertyDecl(D)) return false; } while (false); return true; } bool VisitMSPropertyDecl(MSPropertyDecl *D) { return true; }
bool WalkUpFromNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { do { if (!getDerived().WalkUpFromDeclaratorDecl(D)) return false; } while (false); do { if (!getDerived().VisitNonTypeTemplateParmDecl(D)) return false; } while (false); return true; } bool VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { return true; }
bool WalkUpFromVarDecl(VarDecl *D) { do { if (!getDerived().WalkUpFromDeclaratorDecl(D)) return false; } while (false); do { if (!getDerived().VisitVarDecl(D)) return false; } while (false); return true; } bool VisitVarDecl(VarDecl *D) { return true; }
bool WalkUpFromDecompositionDecl(DecompositionDecl *D) { do { if (!getDerived().WalkUpFromVarDecl(D)) return false; } while (false); do { if (!getDerived().VisitDecompositionDecl(D)) return false; } while (false); return true; } bool VisitDecompositionDecl(DecompositionDecl *D) { return true; }
bool WalkUpFromImplicitParamDecl(ImplicitParamDecl *D) { do { if (!getDerived().WalkUpFromVarDecl(D)) return false; } while (false); do { if (!getDerived().VisitImplicitParamDecl(D)) return false; } while (false); return true; } bool VisitImplicitParamDecl(ImplicitParamDecl *D) { return true; }
bool WalkUpFromOMPCapturedExprDecl(OMPCapturedExprDecl *D) { do { if (!getDerived().WalkUpFromVarDecl(D)) return false; } while (false); do { if (!getDerived().VisitOMPCapturedExprDecl(D)) return false; } while (false); return true; } bool VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) { return true; }
bool WalkUpFromParmVarDecl(ParmVarDecl *D) { do { if (!getDerived().WalkUpFromVarDecl(D)) return false; } while (false); do { if (!getDerived().VisitParmVarDecl(D)) return false; } while (false); return true; } bool VisitParmVarDecl(ParmVarDecl *D) { return true; }
bool WalkUpFromVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D) { do { if (!getDerived().WalkUpFromVarDecl(D)) return false; } while (false); do { if (!getDerived().VisitVarTemplateSpecializationDecl(D)) return false; } while (false); return true; } bool VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D) { return true; }
bool WalkUpFromVarTemplatePartialSpecializationDecl(VarTemplatePartialSpecializationDecl *D) { do { if (!getDerived().WalkUpFromVarTemplateSpecializationDecl(D)) return false; } while (false); do { if (!getDerived().VisitVarTemplatePartialSpecializationDecl(D)) return false; } while (false); return true; } bool VisitVarTemplatePartialSpecializationDecl(VarTemplatePartialSpecializationDecl *D) { return true; }
bool WalkUpFromEnumConstantDecl(EnumConstantDecl *D) { do { if (!getDerived().WalkUpFromValueDecl(D)) return false; } while (false); do { if (!getDerived().VisitEnumConstantDecl(D)) return false; } while (false); return true; } bool VisitEnumConstantDecl(EnumConstantDecl *D) { return true; }
bool WalkUpFromIndirectFieldDecl(IndirectFieldDecl *D) { do { if (!getDerived().WalkUpFromValueDecl(D)) return false; } while (false); do { if (!getDerived().VisitIndirectFieldDecl(D)) return false; } while (false); return true; } bool VisitIndirectFieldDecl(IndirectFieldDecl *D) { return true; }
bool WalkUpFromMSGuidDecl(MSGuidDecl *D) { do { if (!getDerived().WalkUpFromValueDecl(D)) return false; } while (false); do { if (!getDerived().VisitMSGuidDecl(D)) return false; } while (false); return true; } bool VisitMSGuidDecl(MSGuidDecl *D) { return true; }
bool WalkUpFromOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) { do { if (!getDerived().WalkUpFromValueDecl(D)) return false; } while (false); do { if (!getDerived().VisitOMPDeclareMapperDecl(D)) return false; } while (false); return true; } bool VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) { return true; }
bool WalkUpFromOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) { do { if (!getDerived().WalkUpFromValueDecl(D)) return false; } while (false); do { if (!getDerived().VisitOMPDeclareReductionDecl(D)) return false; } while (false); return true; } bool VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) { return true; }
bool WalkUpFromTemplateParamObjectDecl(TemplateParamObjectDecl *D) { do { if (!getDerived().WalkUpFromValueDecl(D)) return false; } while (false); do { if (!getDerived().VisitTemplateParamObjectDecl(D)) return false; } while (false); return true; } bool VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D) { return true; }
bool WalkUpFromUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { do { if (!getDerived().WalkUpFromValueDecl(D)) return false; } while (false); do { if (!getDerived().VisitUnresolvedUsingValueDecl(D)) return false; } while (false); return true; } bool VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { return true; }
bool WalkUpFromOMPAllocateDecl(OMPAllocateDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitOMPAllocateDecl(D)) return false; } while (false); return true; } bool VisitOMPAllocateDecl(OMPAllocateDecl *D) { return true; }
bool WalkUpFromOMPRequiresDecl(OMPRequiresDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitOMPRequiresDecl(D)) return false; } while (false); return true; } bool VisitOMPRequiresDecl(OMPRequiresDecl *D) { return true; }
bool WalkUpFromOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitOMPThreadPrivateDecl(D)) return false; } while (false); return true; } bool VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) { return true; }
bool WalkUpFromObjCPropertyImplDecl(ObjCPropertyImplDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCPropertyImplDecl(D)) return false; } while (false); return true; } bool VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) { return true; }
bool WalkUpFromPragmaCommentDecl(PragmaCommentDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitPragmaCommentDecl(D)) return false; } while (false); return true; } bool VisitPragmaCommentDecl(PragmaCommentDecl *D) { return true; }
bool WalkUpFromPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitPragmaDetectMismatchDecl(D)) return false; } while (false); return true; } bool VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D) { return true; }
bool WalkUpFromRequiresExprBodyDecl(RequiresExprBodyDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitRequiresExprBodyDecl(D)) return false; } while (false); return true; } bool VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D) { return true; }
bool WalkUpFromStaticAssertDecl(StaticAssertDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitStaticAssertDecl(D)) return false; } while (false); return true; } bool VisitStaticAssertDecl(StaticAssertDecl *D) { return true; }
bool WalkUpFromTranslationUnitDecl(TranslationUnitDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitTranslationUnitDecl(D)) return false; } while (false); return true; } bool VisitTranslationUnitDecl(TranslationUnitDecl *D) { return true; }
  bool canIgnoreChildDeclWhileTraversingDeclContext(const Decl *Child);
  bool TraverseTemplateInstantiations(ClassTemplateDecl *D);
  bool TraverseTemplateInstantiations(VarTemplateDecl *D);
  bool TraverseTemplateInstantiations(FunctionTemplateDecl *D);
  bool dataTraverseNode(Stmt *S, DataRecursionQueue *Queue);
private:
  bool TraverseTemplateParameterListHelper(TemplateParameterList *TPL);
  template <typename T>
  bool TraverseDeclTemplateParameterLists(T *D);
  bool TraverseTemplateTypeParamDeclConstraints(const TemplateTypeParmDecl *D);
  bool TraverseTemplateArgumentLocsHelper(const TemplateArgumentLoc *TAL,
                                          unsigned Count);
  bool TraverseArrayTypeLocHelper(ArrayTypeLoc TL);
  bool TraverseRecordHelper(RecordDecl *D);
  bool TraverseCXXRecordHelper(CXXRecordDecl *D);
  bool TraverseDeclaratorHelper(DeclaratorDecl *D);
  bool TraverseDeclContextHelper(DeclContext *DC);
  bool TraverseFunctionHelper(FunctionDecl *D);
  bool TraverseVarHelper(VarDecl *D);
  bool TraverseOMPExecutableDirective(OMPExecutableDirective *S);
  bool TraverseOMPLoopDirective(OMPLoopDirective *S);
  bool TraverseOMPClause(OMPClause *C);
 bool VisitOMPAcqRelClause(OMPAcqRelClause *C);
 bool VisitOMPAcquireClause(OMPAcquireClause *C);
 bool VisitOMPAffinityClause(OMPAffinityClause *C);
 bool VisitOMPAlignedClause(OMPAlignedClause *C);
 bool VisitOMPAllocateClause(OMPAllocateClause *C);
 bool VisitOMPAllocatorClause(OMPAllocatorClause *C);
 bool VisitOMPAtomicDefaultMemOrderClause(OMPAtomicDefaultMemOrderClause *C);
 bool VisitOMPCaptureClause(OMPCaptureClause *C);
 bool VisitOMPCollapseClause(OMPCollapseClause *C);
 bool VisitOMPCopyprivateClause(OMPCopyprivateClause *C);
 bool VisitOMPCopyinClause(OMPCopyinClause *C);
 bool VisitOMPDefaultClause(OMPDefaultClause *C);
 bool VisitOMPDefaultmapClause(OMPDefaultmapClause *C);
 bool VisitOMPDependClause(OMPDependClause *C);
 bool VisitOMPDepobjClause(OMPDepobjClause *C);
 bool VisitOMPDestroyClause(OMPDestroyClause *C);
 bool VisitOMPDetachClause(OMPDetachClause *C);
 bool VisitOMPDeviceClause(OMPDeviceClause *C);
 bool VisitOMPDistScheduleClause(OMPDistScheduleClause *C);
 bool VisitOMPDynamicAllocatorsClause(OMPDynamicAllocatorsClause *C);
 bool VisitOMPExclusiveClause(OMPExclusiveClause *C);
 bool VisitOMPFilterClause(OMPFilterClause *C);
 bool VisitOMPFinalClause(OMPFinalClause *C);
 bool VisitOMPFirstprivateClause(OMPFirstprivateClause *C);
 bool VisitOMPFlushClause(OMPFlushClause *C);
 bool VisitOMPFromClause(OMPFromClause *C);
 bool VisitOMPFullClause(OMPFullClause *C);
 bool VisitOMPGrainsizeClause(OMPGrainsizeClause *C);
 bool VisitOMPHintClause(OMPHintClause *C);
 bool VisitOMPIfClause(OMPIfClause *C);
 bool VisitOMPInReductionClause(OMPInReductionClause *C);
 bool VisitOMPInclusiveClause(OMPInclusiveClause *C);
 bool VisitOMPInitClause(OMPInitClause *C);
 bool VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *C);
 bool VisitOMPLastprivateClause(OMPLastprivateClause *C);
 bool VisitOMPLinearClause(OMPLinearClause *C);
 bool VisitOMPMapClause(OMPMapClause *C);
 bool VisitOMPMergeableClause(OMPMergeableClause *C);
 bool VisitOMPNogroupClause(OMPNogroupClause *C);
 bool VisitOMPNowaitClause(OMPNowaitClause *C);
 bool VisitOMPNocontextClause(OMPNocontextClause *C);
 bool VisitOMPNontemporalClause(OMPNontemporalClause *C);
 bool VisitOMPNovariantsClause(OMPNovariantsClause *C);
 bool VisitOMPNumTasksClause(OMPNumTasksClause *C);
 bool VisitOMPNumTeamsClause(OMPNumTeamsClause *C);
 bool VisitOMPNumThreadsClause(OMPNumThreadsClause *C);
 bool VisitOMPOrderClause(OMPOrderClause *C);
 bool VisitOMPOrderedClause(OMPOrderedClause *C);
 bool VisitOMPPartialClause(OMPPartialClause *C);
 bool VisitOMPPriorityClause(OMPPriorityClause *C);
 bool VisitOMPPrivateClause(OMPPrivateClause *C);
 bool VisitOMPProcBindClause(OMPProcBindClause *C);
 bool VisitOMPReadClause(OMPReadClause *C);
 bool VisitOMPReductionClause(OMPReductionClause *C);
 bool VisitOMPRelaxedClause(OMPRelaxedClause *C);
 bool VisitOMPReleaseClause(OMPReleaseClause *C);
 bool VisitOMPReverseOffloadClause(OMPReverseOffloadClause *C);
 bool VisitOMPSafelenClause(OMPSafelenClause *C);
 bool VisitOMPScheduleClause(OMPScheduleClause *C);
 bool VisitOMPSeqCstClause(OMPSeqCstClause *C);
 bool VisitOMPSharedClause(OMPSharedClause *C);
 bool VisitOMPSIMDClause(OMPSIMDClause *C);
 bool VisitOMPSimdlenClause(OMPSimdlenClause *C);
 bool VisitOMPSizesClause(OMPSizesClause *C);
 bool VisitOMPTaskReductionClause(OMPTaskReductionClause *C);
 bool VisitOMPThreadLimitClause(OMPThreadLimitClause *C);
 bool VisitOMPThreadsClause(OMPThreadsClause *C);
 bool VisitOMPToClause(OMPToClause *C);
 bool VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *C);
 bool VisitOMPUnifiedSharedMemoryClause(OMPUnifiedSharedMemoryClause *C);
 bool VisitOMPUntiedClause(OMPUntiedClause *C);
 bool VisitOMPUpdateClause(OMPUpdateClause *C);
 bool VisitOMPUseClause(OMPUseClause *C);
 bool VisitOMPUseDeviceAddrClause(OMPUseDeviceAddrClause *C);
 bool VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *C);
 bool VisitOMPUsesAllocatorsClause(OMPUsesAllocatorsClause *C);
 bool VisitOMPWriteClause(OMPWriteClause *C);
  template <typename T> bool VisitOMPClauseList(T *Node);
  bool VisitOMPClauseWithPreInit(OMPClauseWithPreInit *Node);
  bool VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *Node);
  bool PostVisitStmt(Stmt *S);
};
template <typename Derived>
bool RecursiveASTVisitor<Derived>::dataTraverseNode(Stmt *S,
                                                    DataRecursionQueue *Queue) {
  switch (S->getStmtClass()) {
  case Stmt::NoStmtClass:
    break;
case Stmt::GCCAsmStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseGCCAsmStmt), decltype(&Derived::TraverseGCCAsmStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseGCCAsmStmt), decltype(&Derived::TraverseGCCAsmStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseGCCAsmStmt(static_cast<GCCAsmStmt *>(S), Queue) : getDerived().TraverseGCCAsmStmt(static_cast<GCCAsmStmt *>(S)));
case Stmt::MSAsmStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMSAsmStmt), decltype(&Derived::TraverseMSAsmStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMSAsmStmt), decltype(&Derived::TraverseMSAsmStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseMSAsmStmt(static_cast<MSAsmStmt *>(S), Queue) : getDerived().TraverseMSAsmStmt(static_cast<MSAsmStmt *>(S)));
case Stmt::BreakStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseBreakStmt), decltype(&Derived::TraverseBreakStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseBreakStmt), decltype(&Derived::TraverseBreakStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseBreakStmt(static_cast<BreakStmt *>(S), Queue) : getDerived().TraverseBreakStmt(static_cast<BreakStmt *>(S)));
case Stmt::CXXCatchStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXCatchStmt), decltype(&Derived::TraverseCXXCatchStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXCatchStmt), decltype(&Derived::TraverseCXXCatchStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXCatchStmt(static_cast<CXXCatchStmt *>(S), Queue) : getDerived().TraverseCXXCatchStmt(static_cast<CXXCatchStmt *>(S)));
case Stmt::CXXForRangeStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXForRangeStmt), decltype(&Derived::TraverseCXXForRangeStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXForRangeStmt), decltype(&Derived::TraverseCXXForRangeStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXForRangeStmt(static_cast<CXXForRangeStmt *>(S), Queue) : getDerived().TraverseCXXForRangeStmt(static_cast<CXXForRangeStmt *>(S)));
case Stmt::CXXTryStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXTryStmt), decltype(&Derived::TraverseCXXTryStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXTryStmt), decltype(&Derived::TraverseCXXTryStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXTryStmt(static_cast<CXXTryStmt *>(S), Queue) : getDerived().TraverseCXXTryStmt(static_cast<CXXTryStmt *>(S)));
case Stmt::CapturedStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCapturedStmt), decltype(&Derived::TraverseCapturedStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCapturedStmt), decltype(&Derived::TraverseCapturedStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCapturedStmt(static_cast<CapturedStmt *>(S), Queue) : getDerived().TraverseCapturedStmt(static_cast<CapturedStmt *>(S)));
case Stmt::CompoundStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCompoundStmt), decltype(&Derived::TraverseCompoundStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCompoundStmt), decltype(&Derived::TraverseCompoundStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCompoundStmt(static_cast<CompoundStmt *>(S), Queue) : getDerived().TraverseCompoundStmt(static_cast<CompoundStmt *>(S)));
case Stmt::ContinueStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseContinueStmt), decltype(&Derived::TraverseContinueStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseContinueStmt), decltype(&Derived::TraverseContinueStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseContinueStmt(static_cast<ContinueStmt *>(S), Queue) : getDerived().TraverseContinueStmt(static_cast<ContinueStmt *>(S)));
case Stmt::CoreturnStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCoreturnStmt), decltype(&Derived::TraverseCoreturnStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCoreturnStmt), decltype(&Derived::TraverseCoreturnStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCoreturnStmt(static_cast<CoreturnStmt *>(S), Queue) : getDerived().TraverseCoreturnStmt(static_cast<CoreturnStmt *>(S)));
case Stmt::CoroutineBodyStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCoroutineBodyStmt), decltype(&Derived::TraverseCoroutineBodyStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCoroutineBodyStmt), decltype(&Derived::TraverseCoroutineBodyStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCoroutineBodyStmt(static_cast<CoroutineBodyStmt *>(S), Queue) : getDerived().TraverseCoroutineBodyStmt(static_cast<CoroutineBodyStmt *>(S)));
case Stmt::DeclStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDeclStmt), decltype(&Derived::TraverseDeclStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDeclStmt), decltype(&Derived::TraverseDeclStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseDeclStmt(static_cast<DeclStmt *>(S), Queue) : getDerived().TraverseDeclStmt(static_cast<DeclStmt *>(S)));
case Stmt::DoStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDoStmt), decltype(&Derived::TraverseDoStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDoStmt), decltype(&Derived::TraverseDoStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseDoStmt(static_cast<DoStmt *>(S), Queue) : getDerived().TraverseDoStmt(static_cast<DoStmt *>(S)));
case Stmt::ForStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseForStmt), decltype(&Derived::TraverseForStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseForStmt), decltype(&Derived::TraverseForStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseForStmt(static_cast<ForStmt *>(S), Queue) : getDerived().TraverseForStmt(static_cast<ForStmt *>(S)));
case Stmt::GotoStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseGotoStmt), decltype(&Derived::TraverseGotoStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseGotoStmt), decltype(&Derived::TraverseGotoStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseGotoStmt(static_cast<GotoStmt *>(S), Queue) : getDerived().TraverseGotoStmt(static_cast<GotoStmt *>(S)));
case Stmt::IfStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseIfStmt), decltype(&Derived::TraverseIfStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseIfStmt), decltype(&Derived::TraverseIfStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseIfStmt(static_cast<IfStmt *>(S), Queue) : getDerived().TraverseIfStmt(static_cast<IfStmt *>(S)));
case Stmt::IndirectGotoStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseIndirectGotoStmt), decltype(&Derived::TraverseIndirectGotoStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseIndirectGotoStmt), decltype(&Derived::TraverseIndirectGotoStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseIndirectGotoStmt(static_cast<IndirectGotoStmt *>(S), Queue) : getDerived().TraverseIndirectGotoStmt(static_cast<IndirectGotoStmt *>(S)));
case Stmt::MSDependentExistsStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMSDependentExistsStmt), decltype(&Derived::TraverseMSDependentExistsStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMSDependentExistsStmt), decltype(&Derived::TraverseMSDependentExistsStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseMSDependentExistsStmt(static_cast<MSDependentExistsStmt *>(S), Queue) : getDerived().TraverseMSDependentExistsStmt(static_cast<MSDependentExistsStmt *>(S)));
case Stmt::NullStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseNullStmt), decltype(&Derived::TraverseNullStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseNullStmt), decltype(&Derived::TraverseNullStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseNullStmt(static_cast<NullStmt *>(S), Queue) : getDerived().TraverseNullStmt(static_cast<NullStmt *>(S)));
case Stmt::OMPCanonicalLoopClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPCanonicalLoop), decltype(&Derived::TraverseOMPCanonicalLoop)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPCanonicalLoop), decltype(&Derived::TraverseOMPCanonicalLoop)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPCanonicalLoop(static_cast<OMPCanonicalLoop *>(S), Queue) : getDerived().TraverseOMPCanonicalLoop(static_cast<OMPCanonicalLoop *>(S)));
case Stmt::OMPAtomicDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPAtomicDirective), decltype(&Derived::TraverseOMPAtomicDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPAtomicDirective), decltype(&Derived::TraverseOMPAtomicDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPAtomicDirective(static_cast<OMPAtomicDirective *>(S), Queue) : getDerived().TraverseOMPAtomicDirective(static_cast<OMPAtomicDirective *>(S)));
case Stmt::OMPBarrierDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPBarrierDirective), decltype(&Derived::TraverseOMPBarrierDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPBarrierDirective), decltype(&Derived::TraverseOMPBarrierDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPBarrierDirective(static_cast<OMPBarrierDirective *>(S), Queue) : getDerived().TraverseOMPBarrierDirective(static_cast<OMPBarrierDirective *>(S)));
case Stmt::OMPCancelDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPCancelDirective), decltype(&Derived::TraverseOMPCancelDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPCancelDirective), decltype(&Derived::TraverseOMPCancelDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPCancelDirective(static_cast<OMPCancelDirective *>(S), Queue) : getDerived().TraverseOMPCancelDirective(static_cast<OMPCancelDirective *>(S)));
case Stmt::OMPCancellationPointDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPCancellationPointDirective), decltype(&Derived::TraverseOMPCancellationPointDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPCancellationPointDirective), decltype(&Derived::TraverseOMPCancellationPointDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPCancellationPointDirective(static_cast<OMPCancellationPointDirective *>(S), Queue) : getDerived().TraverseOMPCancellationPointDirective(static_cast<OMPCancellationPointDirective *>(S)));
case Stmt::OMPCriticalDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPCriticalDirective), decltype(&Derived::TraverseOMPCriticalDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPCriticalDirective), decltype(&Derived::TraverseOMPCriticalDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPCriticalDirective(static_cast<OMPCriticalDirective *>(S), Queue) : getDerived().TraverseOMPCriticalDirective(static_cast<OMPCriticalDirective *>(S)));
case Stmt::OMPDepobjDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDepobjDirective), decltype(&Derived::TraverseOMPDepobjDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDepobjDirective), decltype(&Derived::TraverseOMPDepobjDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPDepobjDirective(static_cast<OMPDepobjDirective *>(S), Queue) : getDerived().TraverseOMPDepobjDirective(static_cast<OMPDepobjDirective *>(S)));
case Stmt::OMPDispatchDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDispatchDirective), decltype(&Derived::TraverseOMPDispatchDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDispatchDirective), decltype(&Derived::TraverseOMPDispatchDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPDispatchDirective(static_cast<OMPDispatchDirective *>(S), Queue) : getDerived().TraverseOMPDispatchDirective(static_cast<OMPDispatchDirective *>(S)));
case Stmt::OMPFlushDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPFlushDirective), decltype(&Derived::TraverseOMPFlushDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPFlushDirective), decltype(&Derived::TraverseOMPFlushDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPFlushDirective(static_cast<OMPFlushDirective *>(S), Queue) : getDerived().TraverseOMPFlushDirective(static_cast<OMPFlushDirective *>(S)));
case Stmt::OMPInteropDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPInteropDirective), decltype(&Derived::TraverseOMPInteropDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPInteropDirective), decltype(&Derived::TraverseOMPInteropDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPInteropDirective(static_cast<OMPInteropDirective *>(S), Queue) : getDerived().TraverseOMPInteropDirective(static_cast<OMPInteropDirective *>(S)));
case Stmt::OMPDistributeDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDistributeDirective), decltype(&Derived::TraverseOMPDistributeDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDistributeDirective), decltype(&Derived::TraverseOMPDistributeDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPDistributeDirective(static_cast<OMPDistributeDirective *>(S), Queue) : getDerived().TraverseOMPDistributeDirective(static_cast<OMPDistributeDirective *>(S)));
case Stmt::OMPDistributeParallelForDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDistributeParallelForDirective), decltype(&Derived::TraverseOMPDistributeParallelForDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDistributeParallelForDirective), decltype(&Derived::TraverseOMPDistributeParallelForDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPDistributeParallelForDirective(static_cast<OMPDistributeParallelForDirective *>(S), Queue) : getDerived().TraverseOMPDistributeParallelForDirective(static_cast<OMPDistributeParallelForDirective *>(S)));
case Stmt::OMPDistributeParallelForSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDistributeParallelForSimdDirective), decltype(&Derived::TraverseOMPDistributeParallelForSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDistributeParallelForSimdDirective), decltype(&Derived::TraverseOMPDistributeParallelForSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPDistributeParallelForSimdDirective(static_cast<OMPDistributeParallelForSimdDirective *>(S), Queue) : getDerived().TraverseOMPDistributeParallelForSimdDirective(static_cast<OMPDistributeParallelForSimdDirective *>(S)));
case Stmt::OMPDistributeSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDistributeSimdDirective), decltype(&Derived::TraverseOMPDistributeSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDistributeSimdDirective), decltype(&Derived::TraverseOMPDistributeSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPDistributeSimdDirective(static_cast<OMPDistributeSimdDirective *>(S), Queue) : getDerived().TraverseOMPDistributeSimdDirective(static_cast<OMPDistributeSimdDirective *>(S)));
case Stmt::OMPForDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPForDirective), decltype(&Derived::TraverseOMPForDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPForDirective), decltype(&Derived::TraverseOMPForDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPForDirective(static_cast<OMPForDirective *>(S), Queue) : getDerived().TraverseOMPForDirective(static_cast<OMPForDirective *>(S)));
case Stmt::OMPForSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPForSimdDirective), decltype(&Derived::TraverseOMPForSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPForSimdDirective), decltype(&Derived::TraverseOMPForSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPForSimdDirective(static_cast<OMPForSimdDirective *>(S), Queue) : getDerived().TraverseOMPForSimdDirective(static_cast<OMPForSimdDirective *>(S)));
case Stmt::OMPMasterTaskLoopDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPMasterTaskLoopDirective), decltype(&Derived::TraverseOMPMasterTaskLoopDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPMasterTaskLoopDirective), decltype(&Derived::TraverseOMPMasterTaskLoopDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPMasterTaskLoopDirective(static_cast<OMPMasterTaskLoopDirective *>(S), Queue) : getDerived().TraverseOMPMasterTaskLoopDirective(static_cast<OMPMasterTaskLoopDirective *>(S)));
case Stmt::OMPMasterTaskLoopSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPMasterTaskLoopSimdDirective), decltype(&Derived::TraverseOMPMasterTaskLoopSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPMasterTaskLoopSimdDirective), decltype(&Derived::TraverseOMPMasterTaskLoopSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPMasterTaskLoopSimdDirective(static_cast<OMPMasterTaskLoopSimdDirective *>(S), Queue) : getDerived().TraverseOMPMasterTaskLoopSimdDirective(static_cast<OMPMasterTaskLoopSimdDirective *>(S)));
case Stmt::OMPParallelForDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelForDirective), decltype(&Derived::TraverseOMPParallelForDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelForDirective), decltype(&Derived::TraverseOMPParallelForDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPParallelForDirective(static_cast<OMPParallelForDirective *>(S), Queue) : getDerived().TraverseOMPParallelForDirective(static_cast<OMPParallelForDirective *>(S)));
case Stmt::OMPParallelForSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelForSimdDirective), decltype(&Derived::TraverseOMPParallelForSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelForSimdDirective), decltype(&Derived::TraverseOMPParallelForSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPParallelForSimdDirective(static_cast<OMPParallelForSimdDirective *>(S), Queue) : getDerived().TraverseOMPParallelForSimdDirective(static_cast<OMPParallelForSimdDirective *>(S)));
case Stmt::OMPParallelMasterTaskLoopDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelMasterTaskLoopDirective), decltype(&Derived::TraverseOMPParallelMasterTaskLoopDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelMasterTaskLoopDirective), decltype(&Derived::TraverseOMPParallelMasterTaskLoopDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPParallelMasterTaskLoopDirective(static_cast<OMPParallelMasterTaskLoopDirective *>(S), Queue) : getDerived().TraverseOMPParallelMasterTaskLoopDirective(static_cast<OMPParallelMasterTaskLoopDirective *>(S)));
case Stmt::OMPParallelMasterTaskLoopSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelMasterTaskLoopSimdDirective), decltype(&Derived::TraverseOMPParallelMasterTaskLoopSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelMasterTaskLoopSimdDirective), decltype(&Derived::TraverseOMPParallelMasterTaskLoopSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPParallelMasterTaskLoopSimdDirective(static_cast<OMPParallelMasterTaskLoopSimdDirective *>(S), Queue) : getDerived().TraverseOMPParallelMasterTaskLoopSimdDirective(static_cast<OMPParallelMasterTaskLoopSimdDirective *>(S)));
case Stmt::OMPSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPSimdDirective), decltype(&Derived::TraverseOMPSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPSimdDirective), decltype(&Derived::TraverseOMPSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPSimdDirective(static_cast<OMPSimdDirective *>(S), Queue) : getDerived().TraverseOMPSimdDirective(static_cast<OMPSimdDirective *>(S)));
case Stmt::OMPTargetParallelForSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetParallelForSimdDirective), decltype(&Derived::TraverseOMPTargetParallelForSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetParallelForSimdDirective), decltype(&Derived::TraverseOMPTargetParallelForSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetParallelForSimdDirective(static_cast<OMPTargetParallelForSimdDirective *>(S), Queue) : getDerived().TraverseOMPTargetParallelForSimdDirective(static_cast<OMPTargetParallelForSimdDirective *>(S)));
case Stmt::OMPTargetSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetSimdDirective), decltype(&Derived::TraverseOMPTargetSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetSimdDirective), decltype(&Derived::TraverseOMPTargetSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetSimdDirective(static_cast<OMPTargetSimdDirective *>(S), Queue) : getDerived().TraverseOMPTargetSimdDirective(static_cast<OMPTargetSimdDirective *>(S)));
case Stmt::OMPTargetTeamsDistributeDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeDirective), decltype(&Derived::TraverseOMPTargetTeamsDistributeDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeDirective), decltype(&Derived::TraverseOMPTargetTeamsDistributeDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetTeamsDistributeDirective(static_cast<OMPTargetTeamsDistributeDirective *>(S), Queue) : getDerived().TraverseOMPTargetTeamsDistributeDirective(static_cast<OMPTargetTeamsDistributeDirective *>(S)));
case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeParallelForDirective), decltype(&Derived::TraverseOMPTargetTeamsDistributeParallelForDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeParallelForDirective), decltype(&Derived::TraverseOMPTargetTeamsDistributeParallelForDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetTeamsDistributeParallelForDirective(static_cast<OMPTargetTeamsDistributeParallelForDirective *>(S), Queue) : getDerived().TraverseOMPTargetTeamsDistributeParallelForDirective(static_cast<OMPTargetTeamsDistributeParallelForDirective *>(S)));
case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeParallelForSimdDirective), decltype(&Derived::TraverseOMPTargetTeamsDistributeParallelForSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeParallelForSimdDirective), decltype(&Derived::TraverseOMPTargetTeamsDistributeParallelForSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetTeamsDistributeParallelForSimdDirective(static_cast<OMPTargetTeamsDistributeParallelForSimdDirective *>(S), Queue) : getDerived().TraverseOMPTargetTeamsDistributeParallelForSimdDirective(static_cast<OMPTargetTeamsDistributeParallelForSimdDirective *>(S)));
case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeSimdDirective), decltype(&Derived::TraverseOMPTargetTeamsDistributeSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeSimdDirective), decltype(&Derived::TraverseOMPTargetTeamsDistributeSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetTeamsDistributeSimdDirective(static_cast<OMPTargetTeamsDistributeSimdDirective *>(S), Queue) : getDerived().TraverseOMPTargetTeamsDistributeSimdDirective(static_cast<OMPTargetTeamsDistributeSimdDirective *>(S)));
case Stmt::OMPTaskLoopDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskLoopDirective), decltype(&Derived::TraverseOMPTaskLoopDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskLoopDirective), decltype(&Derived::TraverseOMPTaskLoopDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTaskLoopDirective(static_cast<OMPTaskLoopDirective *>(S), Queue) : getDerived().TraverseOMPTaskLoopDirective(static_cast<OMPTaskLoopDirective *>(S)));
case Stmt::OMPTaskLoopSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskLoopSimdDirective), decltype(&Derived::TraverseOMPTaskLoopSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskLoopSimdDirective), decltype(&Derived::TraverseOMPTaskLoopSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTaskLoopSimdDirective(static_cast<OMPTaskLoopSimdDirective *>(S), Queue) : getDerived().TraverseOMPTaskLoopSimdDirective(static_cast<OMPTaskLoopSimdDirective *>(S)));
case Stmt::OMPTeamsDistributeDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTeamsDistributeDirective), decltype(&Derived::TraverseOMPTeamsDistributeDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTeamsDistributeDirective), decltype(&Derived::TraverseOMPTeamsDistributeDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTeamsDistributeDirective(static_cast<OMPTeamsDistributeDirective *>(S), Queue) : getDerived().TraverseOMPTeamsDistributeDirective(static_cast<OMPTeamsDistributeDirective *>(S)));
case Stmt::OMPTeamsDistributeParallelForDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTeamsDistributeParallelForDirective), decltype(&Derived::TraverseOMPTeamsDistributeParallelForDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTeamsDistributeParallelForDirective), decltype(&Derived::TraverseOMPTeamsDistributeParallelForDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTeamsDistributeParallelForDirective(static_cast<OMPTeamsDistributeParallelForDirective *>(S), Queue) : getDerived().TraverseOMPTeamsDistributeParallelForDirective(static_cast<OMPTeamsDistributeParallelForDirective *>(S)));
case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTeamsDistributeParallelForSimdDirective), decltype(&Derived::TraverseOMPTeamsDistributeParallelForSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTeamsDistributeParallelForSimdDirective), decltype(&Derived::TraverseOMPTeamsDistributeParallelForSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTeamsDistributeParallelForSimdDirective(static_cast<OMPTeamsDistributeParallelForSimdDirective *>(S), Queue) : getDerived().TraverseOMPTeamsDistributeParallelForSimdDirective(static_cast<OMPTeamsDistributeParallelForSimdDirective *>(S)));
case Stmt::OMPTeamsDistributeSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTeamsDistributeSimdDirective), decltype(&Derived::TraverseOMPTeamsDistributeSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTeamsDistributeSimdDirective), decltype(&Derived::TraverseOMPTeamsDistributeSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTeamsDistributeSimdDirective(static_cast<OMPTeamsDistributeSimdDirective *>(S), Queue) : getDerived().TraverseOMPTeamsDistributeSimdDirective(static_cast<OMPTeamsDistributeSimdDirective *>(S)));
case Stmt::OMPTileDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTileDirective), decltype(&Derived::TraverseOMPTileDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTileDirective), decltype(&Derived::TraverseOMPTileDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTileDirective(static_cast<OMPTileDirective *>(S), Queue) : getDerived().TraverseOMPTileDirective(static_cast<OMPTileDirective *>(S)));
case Stmt::OMPUnrollDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPUnrollDirective), decltype(&Derived::TraverseOMPUnrollDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPUnrollDirective), decltype(&Derived::TraverseOMPUnrollDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPUnrollDirective(static_cast<OMPUnrollDirective *>(S), Queue) : getDerived().TraverseOMPUnrollDirective(static_cast<OMPUnrollDirective *>(S)));
case Stmt::OMPMaskedDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPMaskedDirective), decltype(&Derived::TraverseOMPMaskedDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPMaskedDirective), decltype(&Derived::TraverseOMPMaskedDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPMaskedDirective(static_cast<OMPMaskedDirective *>(S), Queue) : getDerived().TraverseOMPMaskedDirective(static_cast<OMPMaskedDirective *>(S)));
case Stmt::OMPMasterDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPMasterDirective), decltype(&Derived::TraverseOMPMasterDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPMasterDirective), decltype(&Derived::TraverseOMPMasterDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPMasterDirective(static_cast<OMPMasterDirective *>(S), Queue) : getDerived().TraverseOMPMasterDirective(static_cast<OMPMasterDirective *>(S)));
case Stmt::OMPOrderedDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPOrderedDirective), decltype(&Derived::TraverseOMPOrderedDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPOrderedDirective), decltype(&Derived::TraverseOMPOrderedDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPOrderedDirective(static_cast<OMPOrderedDirective *>(S), Queue) : getDerived().TraverseOMPOrderedDirective(static_cast<OMPOrderedDirective *>(S)));
case Stmt::OMPParallelDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelDirective), decltype(&Derived::TraverseOMPParallelDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelDirective), decltype(&Derived::TraverseOMPParallelDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPParallelDirective(static_cast<OMPParallelDirective *>(S), Queue) : getDerived().TraverseOMPParallelDirective(static_cast<OMPParallelDirective *>(S)));
case Stmt::OMPParallelMasterDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelMasterDirective), decltype(&Derived::TraverseOMPParallelMasterDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelMasterDirective), decltype(&Derived::TraverseOMPParallelMasterDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPParallelMasterDirective(static_cast<OMPParallelMasterDirective *>(S), Queue) : getDerived().TraverseOMPParallelMasterDirective(static_cast<OMPParallelMasterDirective *>(S)));
case Stmt::OMPParallelSectionsDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelSectionsDirective), decltype(&Derived::TraverseOMPParallelSectionsDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelSectionsDirective), decltype(&Derived::TraverseOMPParallelSectionsDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPParallelSectionsDirective(static_cast<OMPParallelSectionsDirective *>(S), Queue) : getDerived().TraverseOMPParallelSectionsDirective(static_cast<OMPParallelSectionsDirective *>(S)));
case Stmt::OMPScanDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPScanDirective), decltype(&Derived::TraverseOMPScanDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPScanDirective), decltype(&Derived::TraverseOMPScanDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPScanDirective(static_cast<OMPScanDirective *>(S), Queue) : getDerived().TraverseOMPScanDirective(static_cast<OMPScanDirective *>(S)));
case Stmt::OMPSectionDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPSectionDirective), decltype(&Derived::TraverseOMPSectionDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPSectionDirective), decltype(&Derived::TraverseOMPSectionDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPSectionDirective(static_cast<OMPSectionDirective *>(S), Queue) : getDerived().TraverseOMPSectionDirective(static_cast<OMPSectionDirective *>(S)));
case Stmt::OMPSectionsDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPSectionsDirective), decltype(&Derived::TraverseOMPSectionsDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPSectionsDirective), decltype(&Derived::TraverseOMPSectionsDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPSectionsDirective(static_cast<OMPSectionsDirective *>(S), Queue) : getDerived().TraverseOMPSectionsDirective(static_cast<OMPSectionsDirective *>(S)));
case Stmt::OMPSingleDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPSingleDirective), decltype(&Derived::TraverseOMPSingleDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPSingleDirective), decltype(&Derived::TraverseOMPSingleDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPSingleDirective(static_cast<OMPSingleDirective *>(S), Queue) : getDerived().TraverseOMPSingleDirective(static_cast<OMPSingleDirective *>(S)));
case Stmt::OMPTargetDataDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetDataDirective), decltype(&Derived::TraverseOMPTargetDataDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetDataDirective), decltype(&Derived::TraverseOMPTargetDataDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetDataDirective(static_cast<OMPTargetDataDirective *>(S), Queue) : getDerived().TraverseOMPTargetDataDirective(static_cast<OMPTargetDataDirective *>(S)));
case Stmt::OMPTargetDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetDirective), decltype(&Derived::TraverseOMPTargetDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetDirective), decltype(&Derived::TraverseOMPTargetDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetDirective(static_cast<OMPTargetDirective *>(S), Queue) : getDerived().TraverseOMPTargetDirective(static_cast<OMPTargetDirective *>(S)));
case Stmt::OMPTargetEnterDataDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetEnterDataDirective), decltype(&Derived::TraverseOMPTargetEnterDataDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetEnterDataDirective), decltype(&Derived::TraverseOMPTargetEnterDataDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetEnterDataDirective(static_cast<OMPTargetEnterDataDirective *>(S), Queue) : getDerived().TraverseOMPTargetEnterDataDirective(static_cast<OMPTargetEnterDataDirective *>(S)));
case Stmt::OMPTargetExitDataDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetExitDataDirective), decltype(&Derived::TraverseOMPTargetExitDataDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetExitDataDirective), decltype(&Derived::TraverseOMPTargetExitDataDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetExitDataDirective(static_cast<OMPTargetExitDataDirective *>(S), Queue) : getDerived().TraverseOMPTargetExitDataDirective(static_cast<OMPTargetExitDataDirective *>(S)));
case Stmt::OMPTargetParallelDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetParallelDirective), decltype(&Derived::TraverseOMPTargetParallelDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetParallelDirective), decltype(&Derived::TraverseOMPTargetParallelDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetParallelDirective(static_cast<OMPTargetParallelDirective *>(S), Queue) : getDerived().TraverseOMPTargetParallelDirective(static_cast<OMPTargetParallelDirective *>(S)));
case Stmt::OMPTargetParallelForDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetParallelForDirective), decltype(&Derived::TraverseOMPTargetParallelForDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetParallelForDirective), decltype(&Derived::TraverseOMPTargetParallelForDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetParallelForDirective(static_cast<OMPTargetParallelForDirective *>(S), Queue) : getDerived().TraverseOMPTargetParallelForDirective(static_cast<OMPTargetParallelForDirective *>(S)));
case Stmt::OMPTargetTeamsDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetTeamsDirective), decltype(&Derived::TraverseOMPTargetTeamsDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetTeamsDirective), decltype(&Derived::TraverseOMPTargetTeamsDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetTeamsDirective(static_cast<OMPTargetTeamsDirective *>(S), Queue) : getDerived().TraverseOMPTargetTeamsDirective(static_cast<OMPTargetTeamsDirective *>(S)));
case Stmt::OMPTargetUpdateDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetUpdateDirective), decltype(&Derived::TraverseOMPTargetUpdateDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetUpdateDirective), decltype(&Derived::TraverseOMPTargetUpdateDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetUpdateDirective(static_cast<OMPTargetUpdateDirective *>(S), Queue) : getDerived().TraverseOMPTargetUpdateDirective(static_cast<OMPTargetUpdateDirective *>(S)));
case Stmt::OMPTaskDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskDirective), decltype(&Derived::TraverseOMPTaskDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskDirective), decltype(&Derived::TraverseOMPTaskDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTaskDirective(static_cast<OMPTaskDirective *>(S), Queue) : getDerived().TraverseOMPTaskDirective(static_cast<OMPTaskDirective *>(S)));
case Stmt::OMPTaskgroupDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskgroupDirective), decltype(&Derived::TraverseOMPTaskgroupDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskgroupDirective), decltype(&Derived::TraverseOMPTaskgroupDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTaskgroupDirective(static_cast<OMPTaskgroupDirective *>(S), Queue) : getDerived().TraverseOMPTaskgroupDirective(static_cast<OMPTaskgroupDirective *>(S)));
case Stmt::OMPTaskwaitDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskwaitDirective), decltype(&Derived::TraverseOMPTaskwaitDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskwaitDirective), decltype(&Derived::TraverseOMPTaskwaitDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTaskwaitDirective(static_cast<OMPTaskwaitDirective *>(S), Queue) : getDerived().TraverseOMPTaskwaitDirective(static_cast<OMPTaskwaitDirective *>(S)));
case Stmt::OMPTaskyieldDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskyieldDirective), decltype(&Derived::TraverseOMPTaskyieldDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskyieldDirective), decltype(&Derived::TraverseOMPTaskyieldDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTaskyieldDirective(static_cast<OMPTaskyieldDirective *>(S), Queue) : getDerived().TraverseOMPTaskyieldDirective(static_cast<OMPTaskyieldDirective *>(S)));
case Stmt::OMPTeamsDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTeamsDirective), decltype(&Derived::TraverseOMPTeamsDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTeamsDirective), decltype(&Derived::TraverseOMPTeamsDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTeamsDirective(static_cast<OMPTeamsDirective *>(S), Queue) : getDerived().TraverseOMPTeamsDirective(static_cast<OMPTeamsDirective *>(S)));
case Stmt::ObjCAtCatchStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAtCatchStmt), decltype(&Derived::TraverseObjCAtCatchStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAtCatchStmt), decltype(&Derived::TraverseObjCAtCatchStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCAtCatchStmt(static_cast<ObjCAtCatchStmt *>(S), Queue) : getDerived().TraverseObjCAtCatchStmt(static_cast<ObjCAtCatchStmt *>(S)));
case Stmt::ObjCAtFinallyStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAtFinallyStmt), decltype(&Derived::TraverseObjCAtFinallyStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAtFinallyStmt), decltype(&Derived::TraverseObjCAtFinallyStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCAtFinallyStmt(static_cast<ObjCAtFinallyStmt *>(S), Queue) : getDerived().TraverseObjCAtFinallyStmt(static_cast<ObjCAtFinallyStmt *>(S)));
case Stmt::ObjCAtSynchronizedStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAtSynchronizedStmt), decltype(&Derived::TraverseObjCAtSynchronizedStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAtSynchronizedStmt), decltype(&Derived::TraverseObjCAtSynchronizedStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCAtSynchronizedStmt(static_cast<ObjCAtSynchronizedStmt *>(S), Queue) : getDerived().TraverseObjCAtSynchronizedStmt(static_cast<ObjCAtSynchronizedStmt *>(S)));
case Stmt::ObjCAtThrowStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAtThrowStmt), decltype(&Derived::TraverseObjCAtThrowStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAtThrowStmt), decltype(&Derived::TraverseObjCAtThrowStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCAtThrowStmt(static_cast<ObjCAtThrowStmt *>(S), Queue) : getDerived().TraverseObjCAtThrowStmt(static_cast<ObjCAtThrowStmt *>(S)));
case Stmt::ObjCAtTryStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAtTryStmt), decltype(&Derived::TraverseObjCAtTryStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAtTryStmt), decltype(&Derived::TraverseObjCAtTryStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCAtTryStmt(static_cast<ObjCAtTryStmt *>(S), Queue) : getDerived().TraverseObjCAtTryStmt(static_cast<ObjCAtTryStmt *>(S)));
case Stmt::ObjCAutoreleasePoolStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAutoreleasePoolStmt), decltype(&Derived::TraverseObjCAutoreleasePoolStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAutoreleasePoolStmt), decltype(&Derived::TraverseObjCAutoreleasePoolStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCAutoreleasePoolStmt(static_cast<ObjCAutoreleasePoolStmt *>(S), Queue) : getDerived().TraverseObjCAutoreleasePoolStmt(static_cast<ObjCAutoreleasePoolStmt *>(S)));
case Stmt::ObjCForCollectionStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCForCollectionStmt), decltype(&Derived::TraverseObjCForCollectionStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCForCollectionStmt), decltype(&Derived::TraverseObjCForCollectionStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCForCollectionStmt(static_cast<ObjCForCollectionStmt *>(S), Queue) : getDerived().TraverseObjCForCollectionStmt(static_cast<ObjCForCollectionStmt *>(S)));
case Stmt::ReturnStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseReturnStmt), decltype(&Derived::TraverseReturnStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseReturnStmt), decltype(&Derived::TraverseReturnStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseReturnStmt(static_cast<ReturnStmt *>(S), Queue) : getDerived().TraverseReturnStmt(static_cast<ReturnStmt *>(S)));
case Stmt::SEHExceptStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSEHExceptStmt), decltype(&Derived::TraverseSEHExceptStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSEHExceptStmt), decltype(&Derived::TraverseSEHExceptStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseSEHExceptStmt(static_cast<SEHExceptStmt *>(S), Queue) : getDerived().TraverseSEHExceptStmt(static_cast<SEHExceptStmt *>(S)));
case Stmt::SEHFinallyStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSEHFinallyStmt), decltype(&Derived::TraverseSEHFinallyStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSEHFinallyStmt), decltype(&Derived::TraverseSEHFinallyStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseSEHFinallyStmt(static_cast<SEHFinallyStmt *>(S), Queue) : getDerived().TraverseSEHFinallyStmt(static_cast<SEHFinallyStmt *>(S)));
case Stmt::SEHLeaveStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSEHLeaveStmt), decltype(&Derived::TraverseSEHLeaveStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSEHLeaveStmt), decltype(&Derived::TraverseSEHLeaveStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseSEHLeaveStmt(static_cast<SEHLeaveStmt *>(S), Queue) : getDerived().TraverseSEHLeaveStmt(static_cast<SEHLeaveStmt *>(S)));
case Stmt::SEHTryStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSEHTryStmt), decltype(&Derived::TraverseSEHTryStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSEHTryStmt), decltype(&Derived::TraverseSEHTryStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseSEHTryStmt(static_cast<SEHTryStmt *>(S), Queue) : getDerived().TraverseSEHTryStmt(static_cast<SEHTryStmt *>(S)));
case Stmt::CaseStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCaseStmt), decltype(&Derived::TraverseCaseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCaseStmt), decltype(&Derived::TraverseCaseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCaseStmt(static_cast<CaseStmt *>(S), Queue) : getDerived().TraverseCaseStmt(static_cast<CaseStmt *>(S)));
case Stmt::DefaultStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDefaultStmt), decltype(&Derived::TraverseDefaultStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDefaultStmt), decltype(&Derived::TraverseDefaultStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseDefaultStmt(static_cast<DefaultStmt *>(S), Queue) : getDerived().TraverseDefaultStmt(static_cast<DefaultStmt *>(S)));
case Stmt::SwitchStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSwitchStmt), decltype(&Derived::TraverseSwitchStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSwitchStmt), decltype(&Derived::TraverseSwitchStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseSwitchStmt(static_cast<SwitchStmt *>(S), Queue) : getDerived().TraverseSwitchStmt(static_cast<SwitchStmt *>(S)));
case Stmt::AttributedStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseAttributedStmt), decltype(&Derived::TraverseAttributedStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseAttributedStmt), decltype(&Derived::TraverseAttributedStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseAttributedStmt(static_cast<AttributedStmt *>(S), Queue) : getDerived().TraverseAttributedStmt(static_cast<AttributedStmt *>(S)));
case Stmt::BinaryConditionalOperatorClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseBinaryConditionalOperator), decltype(&Derived::TraverseBinaryConditionalOperator)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseBinaryConditionalOperator), decltype(&Derived::TraverseBinaryConditionalOperator)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseBinaryConditionalOperator(static_cast<BinaryConditionalOperator *>(S), Queue) : getDerived().TraverseBinaryConditionalOperator(static_cast<BinaryConditionalOperator *>(S)));
case Stmt::ConditionalOperatorClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseConditionalOperator), decltype(&Derived::TraverseConditionalOperator)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseConditionalOperator), decltype(&Derived::TraverseConditionalOperator)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseConditionalOperator(static_cast<ConditionalOperator *>(S), Queue) : getDerived().TraverseConditionalOperator(static_cast<ConditionalOperator *>(S)));
case Stmt::AddrLabelExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseAddrLabelExpr), decltype(&Derived::TraverseAddrLabelExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseAddrLabelExpr), decltype(&Derived::TraverseAddrLabelExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseAddrLabelExpr(static_cast<AddrLabelExpr *>(S), Queue) : getDerived().TraverseAddrLabelExpr(static_cast<AddrLabelExpr *>(S)));
case Stmt::ArrayInitIndexExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseArrayInitIndexExpr), decltype(&Derived::TraverseArrayInitIndexExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseArrayInitIndexExpr), decltype(&Derived::TraverseArrayInitIndexExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseArrayInitIndexExpr(static_cast<ArrayInitIndexExpr *>(S), Queue) : getDerived().TraverseArrayInitIndexExpr(static_cast<ArrayInitIndexExpr *>(S)));
case Stmt::ArrayInitLoopExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseArrayInitLoopExpr), decltype(&Derived::TraverseArrayInitLoopExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseArrayInitLoopExpr), decltype(&Derived::TraverseArrayInitLoopExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseArrayInitLoopExpr(static_cast<ArrayInitLoopExpr *>(S), Queue) : getDerived().TraverseArrayInitLoopExpr(static_cast<ArrayInitLoopExpr *>(S)));
case Stmt::ArraySubscriptExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseArraySubscriptExpr), decltype(&Derived::TraverseArraySubscriptExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseArraySubscriptExpr), decltype(&Derived::TraverseArraySubscriptExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseArraySubscriptExpr(static_cast<ArraySubscriptExpr *>(S), Queue) : getDerived().TraverseArraySubscriptExpr(static_cast<ArraySubscriptExpr *>(S)));
case Stmt::ArrayTypeTraitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseArrayTypeTraitExpr), decltype(&Derived::TraverseArrayTypeTraitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseArrayTypeTraitExpr), decltype(&Derived::TraverseArrayTypeTraitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseArrayTypeTraitExpr(static_cast<ArrayTypeTraitExpr *>(S), Queue) : getDerived().TraverseArrayTypeTraitExpr(static_cast<ArrayTypeTraitExpr *>(S)));
case Stmt::AsTypeExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseAsTypeExpr), decltype(&Derived::TraverseAsTypeExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseAsTypeExpr), decltype(&Derived::TraverseAsTypeExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseAsTypeExpr(static_cast<AsTypeExpr *>(S), Queue) : getDerived().TraverseAsTypeExpr(static_cast<AsTypeExpr *>(S)));
case Stmt::AtomicExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseAtomicExpr), decltype(&Derived::TraverseAtomicExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseAtomicExpr), decltype(&Derived::TraverseAtomicExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseAtomicExpr(static_cast<AtomicExpr *>(S), Queue) : getDerived().TraverseAtomicExpr(static_cast<AtomicExpr *>(S)));
case Stmt::BinaryOperatorClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseBinaryOperator), decltype(&Derived::TraverseBinaryOperator)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseBinaryOperator), decltype(&Derived::TraverseBinaryOperator)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseBinaryOperator(static_cast<BinaryOperator *>(S), Queue) : getDerived().TraverseBinaryOperator(static_cast<BinaryOperator *>(S)));
case Stmt::CompoundAssignOperatorClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCompoundAssignOperator), decltype(&Derived::TraverseCompoundAssignOperator)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCompoundAssignOperator), decltype(&Derived::TraverseCompoundAssignOperator)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCompoundAssignOperator(static_cast<CompoundAssignOperator *>(S), Queue) : getDerived().TraverseCompoundAssignOperator(static_cast<CompoundAssignOperator *>(S)));
case Stmt::BlockExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseBlockExpr), decltype(&Derived::TraverseBlockExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseBlockExpr), decltype(&Derived::TraverseBlockExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseBlockExpr(static_cast<BlockExpr *>(S), Queue) : getDerived().TraverseBlockExpr(static_cast<BlockExpr *>(S)));
case Stmt::CXXBindTemporaryExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXBindTemporaryExpr), decltype(&Derived::TraverseCXXBindTemporaryExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXBindTemporaryExpr), decltype(&Derived::TraverseCXXBindTemporaryExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXBindTemporaryExpr(static_cast<CXXBindTemporaryExpr *>(S), Queue) : getDerived().TraverseCXXBindTemporaryExpr(static_cast<CXXBindTemporaryExpr *>(S)));
case Stmt::CXXBoolLiteralExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXBoolLiteralExpr), decltype(&Derived::TraverseCXXBoolLiteralExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXBoolLiteralExpr), decltype(&Derived::TraverseCXXBoolLiteralExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXBoolLiteralExpr(static_cast<CXXBoolLiteralExpr *>(S), Queue) : getDerived().TraverseCXXBoolLiteralExpr(static_cast<CXXBoolLiteralExpr *>(S)));
case Stmt::CXXConstructExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXConstructExpr), decltype(&Derived::TraverseCXXConstructExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXConstructExpr), decltype(&Derived::TraverseCXXConstructExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXConstructExpr(static_cast<CXXConstructExpr *>(S), Queue) : getDerived().TraverseCXXConstructExpr(static_cast<CXXConstructExpr *>(S)));
case Stmt::CXXTemporaryObjectExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXTemporaryObjectExpr), decltype(&Derived::TraverseCXXTemporaryObjectExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXTemporaryObjectExpr), decltype(&Derived::TraverseCXXTemporaryObjectExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXTemporaryObjectExpr(static_cast<CXXTemporaryObjectExpr *>(S), Queue) : getDerived().TraverseCXXTemporaryObjectExpr(static_cast<CXXTemporaryObjectExpr *>(S)));
case Stmt::CXXDefaultArgExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXDefaultArgExpr), decltype(&Derived::TraverseCXXDefaultArgExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXDefaultArgExpr), decltype(&Derived::TraverseCXXDefaultArgExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXDefaultArgExpr(static_cast<CXXDefaultArgExpr *>(S), Queue) : getDerived().TraverseCXXDefaultArgExpr(static_cast<CXXDefaultArgExpr *>(S)));
case Stmt::CXXDefaultInitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXDefaultInitExpr), decltype(&Derived::TraverseCXXDefaultInitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXDefaultInitExpr), decltype(&Derived::TraverseCXXDefaultInitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXDefaultInitExpr(static_cast<CXXDefaultInitExpr *>(S), Queue) : getDerived().TraverseCXXDefaultInitExpr(static_cast<CXXDefaultInitExpr *>(S)));
case Stmt::CXXDeleteExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXDeleteExpr), decltype(&Derived::TraverseCXXDeleteExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXDeleteExpr), decltype(&Derived::TraverseCXXDeleteExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXDeleteExpr(static_cast<CXXDeleteExpr *>(S), Queue) : getDerived().TraverseCXXDeleteExpr(static_cast<CXXDeleteExpr *>(S)));
case Stmt::CXXDependentScopeMemberExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXDependentScopeMemberExpr), decltype(&Derived::TraverseCXXDependentScopeMemberExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXDependentScopeMemberExpr), decltype(&Derived::TraverseCXXDependentScopeMemberExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXDependentScopeMemberExpr(static_cast<CXXDependentScopeMemberExpr *>(S), Queue) : getDerived().TraverseCXXDependentScopeMemberExpr(static_cast<CXXDependentScopeMemberExpr *>(S)));
case Stmt::CXXFoldExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXFoldExpr), decltype(&Derived::TraverseCXXFoldExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXFoldExpr), decltype(&Derived::TraverseCXXFoldExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXFoldExpr(static_cast<CXXFoldExpr *>(S), Queue) : getDerived().TraverseCXXFoldExpr(static_cast<CXXFoldExpr *>(S)));
case Stmt::CXXInheritedCtorInitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXInheritedCtorInitExpr), decltype(&Derived::TraverseCXXInheritedCtorInitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXInheritedCtorInitExpr), decltype(&Derived::TraverseCXXInheritedCtorInitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXInheritedCtorInitExpr(static_cast<CXXInheritedCtorInitExpr *>(S), Queue) : getDerived().TraverseCXXInheritedCtorInitExpr(static_cast<CXXInheritedCtorInitExpr *>(S)));
case Stmt::CXXNewExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXNewExpr), decltype(&Derived::TraverseCXXNewExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXNewExpr), decltype(&Derived::TraverseCXXNewExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXNewExpr(static_cast<CXXNewExpr *>(S), Queue) : getDerived().TraverseCXXNewExpr(static_cast<CXXNewExpr *>(S)));
case Stmt::CXXNoexceptExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXNoexceptExpr), decltype(&Derived::TraverseCXXNoexceptExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXNoexceptExpr), decltype(&Derived::TraverseCXXNoexceptExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXNoexceptExpr(static_cast<CXXNoexceptExpr *>(S), Queue) : getDerived().TraverseCXXNoexceptExpr(static_cast<CXXNoexceptExpr *>(S)));
case Stmt::CXXNullPtrLiteralExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXNullPtrLiteralExpr), decltype(&Derived::TraverseCXXNullPtrLiteralExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXNullPtrLiteralExpr), decltype(&Derived::TraverseCXXNullPtrLiteralExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXNullPtrLiteralExpr(static_cast<CXXNullPtrLiteralExpr *>(S), Queue) : getDerived().TraverseCXXNullPtrLiteralExpr(static_cast<CXXNullPtrLiteralExpr *>(S)));
case Stmt::CXXPseudoDestructorExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXPseudoDestructorExpr), decltype(&Derived::TraverseCXXPseudoDestructorExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXPseudoDestructorExpr), decltype(&Derived::TraverseCXXPseudoDestructorExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXPseudoDestructorExpr(static_cast<CXXPseudoDestructorExpr *>(S), Queue) : getDerived().TraverseCXXPseudoDestructorExpr(static_cast<CXXPseudoDestructorExpr *>(S)));
case Stmt::CXXRewrittenBinaryOperatorClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXRewrittenBinaryOperator), decltype(&Derived::TraverseCXXRewrittenBinaryOperator)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXRewrittenBinaryOperator), decltype(&Derived::TraverseCXXRewrittenBinaryOperator)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXRewrittenBinaryOperator(static_cast<CXXRewrittenBinaryOperator *>(S), Queue) : getDerived().TraverseCXXRewrittenBinaryOperator(static_cast<CXXRewrittenBinaryOperator *>(S)));
case Stmt::CXXScalarValueInitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXScalarValueInitExpr), decltype(&Derived::TraverseCXXScalarValueInitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXScalarValueInitExpr), decltype(&Derived::TraverseCXXScalarValueInitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXScalarValueInitExpr(static_cast<CXXScalarValueInitExpr *>(S), Queue) : getDerived().TraverseCXXScalarValueInitExpr(static_cast<CXXScalarValueInitExpr *>(S)));
case Stmt::CXXStdInitializerListExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXStdInitializerListExpr), decltype(&Derived::TraverseCXXStdInitializerListExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXStdInitializerListExpr), decltype(&Derived::TraverseCXXStdInitializerListExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXStdInitializerListExpr(static_cast<CXXStdInitializerListExpr *>(S), Queue) : getDerived().TraverseCXXStdInitializerListExpr(static_cast<CXXStdInitializerListExpr *>(S)));
case Stmt::CXXThisExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXThisExpr), decltype(&Derived::TraverseCXXThisExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXThisExpr), decltype(&Derived::TraverseCXXThisExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXThisExpr(static_cast<CXXThisExpr *>(S), Queue) : getDerived().TraverseCXXThisExpr(static_cast<CXXThisExpr *>(S)));
case Stmt::CXXThrowExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXThrowExpr), decltype(&Derived::TraverseCXXThrowExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXThrowExpr), decltype(&Derived::TraverseCXXThrowExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXThrowExpr(static_cast<CXXThrowExpr *>(S), Queue) : getDerived().TraverseCXXThrowExpr(static_cast<CXXThrowExpr *>(S)));
case Stmt::CXXTypeidExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXTypeidExpr), decltype(&Derived::TraverseCXXTypeidExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXTypeidExpr), decltype(&Derived::TraverseCXXTypeidExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXTypeidExpr(static_cast<CXXTypeidExpr *>(S), Queue) : getDerived().TraverseCXXTypeidExpr(static_cast<CXXTypeidExpr *>(S)));
case Stmt::CXXUnresolvedConstructExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXUnresolvedConstructExpr), decltype(&Derived::TraverseCXXUnresolvedConstructExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXUnresolvedConstructExpr), decltype(&Derived::TraverseCXXUnresolvedConstructExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXUnresolvedConstructExpr(static_cast<CXXUnresolvedConstructExpr *>(S), Queue) : getDerived().TraverseCXXUnresolvedConstructExpr(static_cast<CXXUnresolvedConstructExpr *>(S)));
case Stmt::CXXUuidofExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXUuidofExpr), decltype(&Derived::TraverseCXXUuidofExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXUuidofExpr), decltype(&Derived::TraverseCXXUuidofExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXUuidofExpr(static_cast<CXXUuidofExpr *>(S), Queue) : getDerived().TraverseCXXUuidofExpr(static_cast<CXXUuidofExpr *>(S)));
case Stmt::CallExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCallExpr), decltype(&Derived::TraverseCallExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCallExpr), decltype(&Derived::TraverseCallExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCallExpr(static_cast<CallExpr *>(S), Queue) : getDerived().TraverseCallExpr(static_cast<CallExpr *>(S)));
case Stmt::CUDAKernelCallExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCUDAKernelCallExpr), decltype(&Derived::TraverseCUDAKernelCallExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCUDAKernelCallExpr), decltype(&Derived::TraverseCUDAKernelCallExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCUDAKernelCallExpr(static_cast<CUDAKernelCallExpr *>(S), Queue) : getDerived().TraverseCUDAKernelCallExpr(static_cast<CUDAKernelCallExpr *>(S)));
case Stmt::CXXMemberCallExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXMemberCallExpr), decltype(&Derived::TraverseCXXMemberCallExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXMemberCallExpr), decltype(&Derived::TraverseCXXMemberCallExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXMemberCallExpr(static_cast<CXXMemberCallExpr *>(S), Queue) : getDerived().TraverseCXXMemberCallExpr(static_cast<CXXMemberCallExpr *>(S)));
case Stmt::CXXOperatorCallExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXOperatorCallExpr), decltype(&Derived::TraverseCXXOperatorCallExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXOperatorCallExpr), decltype(&Derived::TraverseCXXOperatorCallExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXOperatorCallExpr(static_cast<CXXOperatorCallExpr *>(S), Queue) : getDerived().TraverseCXXOperatorCallExpr(static_cast<CXXOperatorCallExpr *>(S)));
case Stmt::UserDefinedLiteralClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseUserDefinedLiteral), decltype(&Derived::TraverseUserDefinedLiteral)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseUserDefinedLiteral), decltype(&Derived::TraverseUserDefinedLiteral)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseUserDefinedLiteral(static_cast<UserDefinedLiteral *>(S), Queue) : getDerived().TraverseUserDefinedLiteral(static_cast<UserDefinedLiteral *>(S)));
case Stmt::BuiltinBitCastExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseBuiltinBitCastExpr), decltype(&Derived::TraverseBuiltinBitCastExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseBuiltinBitCastExpr), decltype(&Derived::TraverseBuiltinBitCastExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseBuiltinBitCastExpr(static_cast<BuiltinBitCastExpr *>(S), Queue) : getDerived().TraverseBuiltinBitCastExpr(static_cast<BuiltinBitCastExpr *>(S)));
case Stmt::CStyleCastExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCStyleCastExpr), decltype(&Derived::TraverseCStyleCastExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCStyleCastExpr), decltype(&Derived::TraverseCStyleCastExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCStyleCastExpr(static_cast<CStyleCastExpr *>(S), Queue) : getDerived().TraverseCStyleCastExpr(static_cast<CStyleCastExpr *>(S)));
case Stmt::CXXFunctionalCastExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXFunctionalCastExpr), decltype(&Derived::TraverseCXXFunctionalCastExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXFunctionalCastExpr), decltype(&Derived::TraverseCXXFunctionalCastExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXFunctionalCastExpr(static_cast<CXXFunctionalCastExpr *>(S), Queue) : getDerived().TraverseCXXFunctionalCastExpr(static_cast<CXXFunctionalCastExpr *>(S)));
case Stmt::CXXAddrspaceCastExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXAddrspaceCastExpr), decltype(&Derived::TraverseCXXAddrspaceCastExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXAddrspaceCastExpr), decltype(&Derived::TraverseCXXAddrspaceCastExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXAddrspaceCastExpr(static_cast<CXXAddrspaceCastExpr *>(S), Queue) : getDerived().TraverseCXXAddrspaceCastExpr(static_cast<CXXAddrspaceCastExpr *>(S)));
case Stmt::CXXConstCastExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXConstCastExpr), decltype(&Derived::TraverseCXXConstCastExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXConstCastExpr), decltype(&Derived::TraverseCXXConstCastExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXConstCastExpr(static_cast<CXXConstCastExpr *>(S), Queue) : getDerived().TraverseCXXConstCastExpr(static_cast<CXXConstCastExpr *>(S)));
case Stmt::CXXDynamicCastExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXDynamicCastExpr), decltype(&Derived::TraverseCXXDynamicCastExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXDynamicCastExpr), decltype(&Derived::TraverseCXXDynamicCastExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXDynamicCastExpr(static_cast<CXXDynamicCastExpr *>(S), Queue) : getDerived().TraverseCXXDynamicCastExpr(static_cast<CXXDynamicCastExpr *>(S)));
case Stmt::CXXReinterpretCastExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXReinterpretCastExpr), decltype(&Derived::TraverseCXXReinterpretCastExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXReinterpretCastExpr), decltype(&Derived::TraverseCXXReinterpretCastExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXReinterpretCastExpr(static_cast<CXXReinterpretCastExpr *>(S), Queue) : getDerived().TraverseCXXReinterpretCastExpr(static_cast<CXXReinterpretCastExpr *>(S)));
case Stmt::CXXStaticCastExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXStaticCastExpr), decltype(&Derived::TraverseCXXStaticCastExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXStaticCastExpr), decltype(&Derived::TraverseCXXStaticCastExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXStaticCastExpr(static_cast<CXXStaticCastExpr *>(S), Queue) : getDerived().TraverseCXXStaticCastExpr(static_cast<CXXStaticCastExpr *>(S)));
case Stmt::ObjCBridgedCastExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCBridgedCastExpr), decltype(&Derived::TraverseObjCBridgedCastExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCBridgedCastExpr), decltype(&Derived::TraverseObjCBridgedCastExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCBridgedCastExpr(static_cast<ObjCBridgedCastExpr *>(S), Queue) : getDerived().TraverseObjCBridgedCastExpr(static_cast<ObjCBridgedCastExpr *>(S)));
case Stmt::ImplicitCastExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseImplicitCastExpr), decltype(&Derived::TraverseImplicitCastExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseImplicitCastExpr), decltype(&Derived::TraverseImplicitCastExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseImplicitCastExpr(static_cast<ImplicitCastExpr *>(S), Queue) : getDerived().TraverseImplicitCastExpr(static_cast<ImplicitCastExpr *>(S)));
case Stmt::CharacterLiteralClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCharacterLiteral), decltype(&Derived::TraverseCharacterLiteral)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCharacterLiteral), decltype(&Derived::TraverseCharacterLiteral)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCharacterLiteral(static_cast<CharacterLiteral *>(S), Queue) : getDerived().TraverseCharacterLiteral(static_cast<CharacterLiteral *>(S)));
case Stmt::ChooseExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseChooseExpr), decltype(&Derived::TraverseChooseExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseChooseExpr), decltype(&Derived::TraverseChooseExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseChooseExpr(static_cast<ChooseExpr *>(S), Queue) : getDerived().TraverseChooseExpr(static_cast<ChooseExpr *>(S)));
case Stmt::CompoundLiteralExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCompoundLiteralExpr), decltype(&Derived::TraverseCompoundLiteralExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCompoundLiteralExpr), decltype(&Derived::TraverseCompoundLiteralExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCompoundLiteralExpr(static_cast<CompoundLiteralExpr *>(S), Queue) : getDerived().TraverseCompoundLiteralExpr(static_cast<CompoundLiteralExpr *>(S)));
case Stmt::ConceptSpecializationExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseConceptSpecializationExpr), decltype(&Derived::TraverseConceptSpecializationExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseConceptSpecializationExpr), decltype(&Derived::TraverseConceptSpecializationExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseConceptSpecializationExpr(static_cast<ConceptSpecializationExpr *>(S), Queue) : getDerived().TraverseConceptSpecializationExpr(static_cast<ConceptSpecializationExpr *>(S)));
case Stmt::ConvertVectorExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseConvertVectorExpr), decltype(&Derived::TraverseConvertVectorExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseConvertVectorExpr), decltype(&Derived::TraverseConvertVectorExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseConvertVectorExpr(static_cast<ConvertVectorExpr *>(S), Queue) : getDerived().TraverseConvertVectorExpr(static_cast<ConvertVectorExpr *>(S)));
case Stmt::CoawaitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCoawaitExpr), decltype(&Derived::TraverseCoawaitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCoawaitExpr), decltype(&Derived::TraverseCoawaitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCoawaitExpr(static_cast<CoawaitExpr *>(S), Queue) : getDerived().TraverseCoawaitExpr(static_cast<CoawaitExpr *>(S)));
case Stmt::CoyieldExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCoyieldExpr), decltype(&Derived::TraverseCoyieldExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCoyieldExpr), decltype(&Derived::TraverseCoyieldExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCoyieldExpr(static_cast<CoyieldExpr *>(S), Queue) : getDerived().TraverseCoyieldExpr(static_cast<CoyieldExpr *>(S)));
case Stmt::DeclRefExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDeclRefExpr), decltype(&Derived::TraverseDeclRefExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDeclRefExpr), decltype(&Derived::TraverseDeclRefExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseDeclRefExpr(static_cast<DeclRefExpr *>(S), Queue) : getDerived().TraverseDeclRefExpr(static_cast<DeclRefExpr *>(S)));
case Stmt::DependentCoawaitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDependentCoawaitExpr), decltype(&Derived::TraverseDependentCoawaitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDependentCoawaitExpr), decltype(&Derived::TraverseDependentCoawaitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseDependentCoawaitExpr(static_cast<DependentCoawaitExpr *>(S), Queue) : getDerived().TraverseDependentCoawaitExpr(static_cast<DependentCoawaitExpr *>(S)));
case Stmt::DependentScopeDeclRefExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDependentScopeDeclRefExpr), decltype(&Derived::TraverseDependentScopeDeclRefExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDependentScopeDeclRefExpr), decltype(&Derived::TraverseDependentScopeDeclRefExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseDependentScopeDeclRefExpr(static_cast<DependentScopeDeclRefExpr *>(S), Queue) : getDerived().TraverseDependentScopeDeclRefExpr(static_cast<DependentScopeDeclRefExpr *>(S)));
case Stmt::DesignatedInitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDesignatedInitExpr), decltype(&Derived::TraverseDesignatedInitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDesignatedInitExpr), decltype(&Derived::TraverseDesignatedInitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseDesignatedInitExpr(static_cast<DesignatedInitExpr *>(S), Queue) : getDerived().TraverseDesignatedInitExpr(static_cast<DesignatedInitExpr *>(S)));
case Stmt::DesignatedInitUpdateExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDesignatedInitUpdateExpr), decltype(&Derived::TraverseDesignatedInitUpdateExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDesignatedInitUpdateExpr), decltype(&Derived::TraverseDesignatedInitUpdateExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseDesignatedInitUpdateExpr(static_cast<DesignatedInitUpdateExpr *>(S), Queue) : getDerived().TraverseDesignatedInitUpdateExpr(static_cast<DesignatedInitUpdateExpr *>(S)));
case Stmt::ExpressionTraitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseExpressionTraitExpr), decltype(&Derived::TraverseExpressionTraitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseExpressionTraitExpr), decltype(&Derived::TraverseExpressionTraitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseExpressionTraitExpr(static_cast<ExpressionTraitExpr *>(S), Queue) : getDerived().TraverseExpressionTraitExpr(static_cast<ExpressionTraitExpr *>(S)));
case Stmt::ExtVectorElementExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseExtVectorElementExpr), decltype(&Derived::TraverseExtVectorElementExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseExtVectorElementExpr), decltype(&Derived::TraverseExtVectorElementExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseExtVectorElementExpr(static_cast<ExtVectorElementExpr *>(S), Queue) : getDerived().TraverseExtVectorElementExpr(static_cast<ExtVectorElementExpr *>(S)));
case Stmt::FixedPointLiteralClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseFixedPointLiteral), decltype(&Derived::TraverseFixedPointLiteral)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseFixedPointLiteral), decltype(&Derived::TraverseFixedPointLiteral)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseFixedPointLiteral(static_cast<FixedPointLiteral *>(S), Queue) : getDerived().TraverseFixedPointLiteral(static_cast<FixedPointLiteral *>(S)));
case Stmt::FloatingLiteralClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseFloatingLiteral), decltype(&Derived::TraverseFloatingLiteral)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseFloatingLiteral), decltype(&Derived::TraverseFloatingLiteral)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseFloatingLiteral(static_cast<FloatingLiteral *>(S), Queue) : getDerived().TraverseFloatingLiteral(static_cast<FloatingLiteral *>(S)));
case Stmt::ConstantExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseConstantExpr), decltype(&Derived::TraverseConstantExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseConstantExpr), decltype(&Derived::TraverseConstantExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseConstantExpr(static_cast<ConstantExpr *>(S), Queue) : getDerived().TraverseConstantExpr(static_cast<ConstantExpr *>(S)));
case Stmt::ExprWithCleanupsClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseExprWithCleanups), decltype(&Derived::TraverseExprWithCleanups)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseExprWithCleanups), decltype(&Derived::TraverseExprWithCleanups)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseExprWithCleanups(static_cast<ExprWithCleanups *>(S), Queue) : getDerived().TraverseExprWithCleanups(static_cast<ExprWithCleanups *>(S)));
case Stmt::FunctionParmPackExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseFunctionParmPackExpr), decltype(&Derived::TraverseFunctionParmPackExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseFunctionParmPackExpr), decltype(&Derived::TraverseFunctionParmPackExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseFunctionParmPackExpr(static_cast<FunctionParmPackExpr *>(S), Queue) : getDerived().TraverseFunctionParmPackExpr(static_cast<FunctionParmPackExpr *>(S)));
case Stmt::GNUNullExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseGNUNullExpr), decltype(&Derived::TraverseGNUNullExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseGNUNullExpr), decltype(&Derived::TraverseGNUNullExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseGNUNullExpr(static_cast<GNUNullExpr *>(S), Queue) : getDerived().TraverseGNUNullExpr(static_cast<GNUNullExpr *>(S)));
case Stmt::GenericSelectionExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseGenericSelectionExpr), decltype(&Derived::TraverseGenericSelectionExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseGenericSelectionExpr), decltype(&Derived::TraverseGenericSelectionExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseGenericSelectionExpr(static_cast<GenericSelectionExpr *>(S), Queue) : getDerived().TraverseGenericSelectionExpr(static_cast<GenericSelectionExpr *>(S)));
case Stmt::ImaginaryLiteralClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseImaginaryLiteral), decltype(&Derived::TraverseImaginaryLiteral)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseImaginaryLiteral), decltype(&Derived::TraverseImaginaryLiteral)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseImaginaryLiteral(static_cast<ImaginaryLiteral *>(S), Queue) : getDerived().TraverseImaginaryLiteral(static_cast<ImaginaryLiteral *>(S)));
case Stmt::ImplicitValueInitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseImplicitValueInitExpr), decltype(&Derived::TraverseImplicitValueInitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseImplicitValueInitExpr), decltype(&Derived::TraverseImplicitValueInitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseImplicitValueInitExpr(static_cast<ImplicitValueInitExpr *>(S), Queue) : getDerived().TraverseImplicitValueInitExpr(static_cast<ImplicitValueInitExpr *>(S)));
case Stmt::InitListExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseInitListExpr), decltype(&Derived::TraverseInitListExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseInitListExpr), decltype(&Derived::TraverseInitListExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseInitListExpr(static_cast<InitListExpr *>(S), Queue) : getDerived().TraverseInitListExpr(static_cast<InitListExpr *>(S)));
case Stmt::IntegerLiteralClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseIntegerLiteral), decltype(&Derived::TraverseIntegerLiteral)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseIntegerLiteral), decltype(&Derived::TraverseIntegerLiteral)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseIntegerLiteral(static_cast<IntegerLiteral *>(S), Queue) : getDerived().TraverseIntegerLiteral(static_cast<IntegerLiteral *>(S)));
case Stmt::LambdaExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseLambdaExpr), decltype(&Derived::TraverseLambdaExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseLambdaExpr), decltype(&Derived::TraverseLambdaExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseLambdaExpr(static_cast<LambdaExpr *>(S), Queue) : getDerived().TraverseLambdaExpr(static_cast<LambdaExpr *>(S)));
case Stmt::MSPropertyRefExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMSPropertyRefExpr), decltype(&Derived::TraverseMSPropertyRefExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMSPropertyRefExpr), decltype(&Derived::TraverseMSPropertyRefExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseMSPropertyRefExpr(static_cast<MSPropertyRefExpr *>(S), Queue) : getDerived().TraverseMSPropertyRefExpr(static_cast<MSPropertyRefExpr *>(S)));
case Stmt::MSPropertySubscriptExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMSPropertySubscriptExpr), decltype(&Derived::TraverseMSPropertySubscriptExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMSPropertySubscriptExpr), decltype(&Derived::TraverseMSPropertySubscriptExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseMSPropertySubscriptExpr(static_cast<MSPropertySubscriptExpr *>(S), Queue) : getDerived().TraverseMSPropertySubscriptExpr(static_cast<MSPropertySubscriptExpr *>(S)));
case Stmt::MaterializeTemporaryExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMaterializeTemporaryExpr), decltype(&Derived::TraverseMaterializeTemporaryExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMaterializeTemporaryExpr), decltype(&Derived::TraverseMaterializeTemporaryExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseMaterializeTemporaryExpr(static_cast<MaterializeTemporaryExpr *>(S), Queue) : getDerived().TraverseMaterializeTemporaryExpr(static_cast<MaterializeTemporaryExpr *>(S)));
case Stmt::MatrixSubscriptExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMatrixSubscriptExpr), decltype(&Derived::TraverseMatrixSubscriptExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMatrixSubscriptExpr), decltype(&Derived::TraverseMatrixSubscriptExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseMatrixSubscriptExpr(static_cast<MatrixSubscriptExpr *>(S), Queue) : getDerived().TraverseMatrixSubscriptExpr(static_cast<MatrixSubscriptExpr *>(S)));
case Stmt::MemberExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMemberExpr), decltype(&Derived::TraverseMemberExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMemberExpr), decltype(&Derived::TraverseMemberExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseMemberExpr(static_cast<MemberExpr *>(S), Queue) : getDerived().TraverseMemberExpr(static_cast<MemberExpr *>(S)));
case Stmt::NoInitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseNoInitExpr), decltype(&Derived::TraverseNoInitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseNoInitExpr), decltype(&Derived::TraverseNoInitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseNoInitExpr(static_cast<NoInitExpr *>(S), Queue) : getDerived().TraverseNoInitExpr(static_cast<NoInitExpr *>(S)));
case Stmt::OMPArraySectionExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPArraySectionExpr), decltype(&Derived::TraverseOMPArraySectionExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPArraySectionExpr), decltype(&Derived::TraverseOMPArraySectionExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPArraySectionExpr(static_cast<OMPArraySectionExpr *>(S), Queue) : getDerived().TraverseOMPArraySectionExpr(static_cast<OMPArraySectionExpr *>(S)));
case Stmt::OMPArrayShapingExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPArrayShapingExpr), decltype(&Derived::TraverseOMPArrayShapingExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPArrayShapingExpr), decltype(&Derived::TraverseOMPArrayShapingExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPArrayShapingExpr(static_cast<OMPArrayShapingExpr *>(S), Queue) : getDerived().TraverseOMPArrayShapingExpr(static_cast<OMPArrayShapingExpr *>(S)));
case Stmt::OMPIteratorExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPIteratorExpr), decltype(&Derived::TraverseOMPIteratorExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPIteratorExpr), decltype(&Derived::TraverseOMPIteratorExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPIteratorExpr(static_cast<OMPIteratorExpr *>(S), Queue) : getDerived().TraverseOMPIteratorExpr(static_cast<OMPIteratorExpr *>(S)));
case Stmt::ObjCArrayLiteralClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCArrayLiteral), decltype(&Derived::TraverseObjCArrayLiteral)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCArrayLiteral), decltype(&Derived::TraverseObjCArrayLiteral)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCArrayLiteral(static_cast<ObjCArrayLiteral *>(S), Queue) : getDerived().TraverseObjCArrayLiteral(static_cast<ObjCArrayLiteral *>(S)));
case Stmt::ObjCAvailabilityCheckExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAvailabilityCheckExpr), decltype(&Derived::TraverseObjCAvailabilityCheckExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAvailabilityCheckExpr), decltype(&Derived::TraverseObjCAvailabilityCheckExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCAvailabilityCheckExpr(static_cast<ObjCAvailabilityCheckExpr *>(S), Queue) : getDerived().TraverseObjCAvailabilityCheckExpr(static_cast<ObjCAvailabilityCheckExpr *>(S)));
case Stmt::ObjCBoolLiteralExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCBoolLiteralExpr), decltype(&Derived::TraverseObjCBoolLiteralExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCBoolLiteralExpr), decltype(&Derived::TraverseObjCBoolLiteralExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCBoolLiteralExpr(static_cast<ObjCBoolLiteralExpr *>(S), Queue) : getDerived().TraverseObjCBoolLiteralExpr(static_cast<ObjCBoolLiteralExpr *>(S)));
case Stmt::ObjCBoxedExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCBoxedExpr), decltype(&Derived::TraverseObjCBoxedExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCBoxedExpr), decltype(&Derived::TraverseObjCBoxedExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCBoxedExpr(static_cast<ObjCBoxedExpr *>(S), Queue) : getDerived().TraverseObjCBoxedExpr(static_cast<ObjCBoxedExpr *>(S)));
case Stmt::ObjCDictionaryLiteralClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCDictionaryLiteral), decltype(&Derived::TraverseObjCDictionaryLiteral)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCDictionaryLiteral), decltype(&Derived::TraverseObjCDictionaryLiteral)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCDictionaryLiteral(static_cast<ObjCDictionaryLiteral *>(S), Queue) : getDerived().TraverseObjCDictionaryLiteral(static_cast<ObjCDictionaryLiteral *>(S)));
case Stmt::ObjCEncodeExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCEncodeExpr), decltype(&Derived::TraverseObjCEncodeExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCEncodeExpr), decltype(&Derived::TraverseObjCEncodeExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCEncodeExpr(static_cast<ObjCEncodeExpr *>(S), Queue) : getDerived().TraverseObjCEncodeExpr(static_cast<ObjCEncodeExpr *>(S)));
case Stmt::ObjCIndirectCopyRestoreExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCIndirectCopyRestoreExpr), decltype(&Derived::TraverseObjCIndirectCopyRestoreExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCIndirectCopyRestoreExpr), decltype(&Derived::TraverseObjCIndirectCopyRestoreExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCIndirectCopyRestoreExpr(static_cast<ObjCIndirectCopyRestoreExpr *>(S), Queue) : getDerived().TraverseObjCIndirectCopyRestoreExpr(static_cast<ObjCIndirectCopyRestoreExpr *>(S)));
case Stmt::ObjCIsaExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCIsaExpr), decltype(&Derived::TraverseObjCIsaExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCIsaExpr), decltype(&Derived::TraverseObjCIsaExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCIsaExpr(static_cast<ObjCIsaExpr *>(S), Queue) : getDerived().TraverseObjCIsaExpr(static_cast<ObjCIsaExpr *>(S)));
case Stmt::ObjCIvarRefExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCIvarRefExpr), decltype(&Derived::TraverseObjCIvarRefExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCIvarRefExpr), decltype(&Derived::TraverseObjCIvarRefExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCIvarRefExpr(static_cast<ObjCIvarRefExpr *>(S), Queue) : getDerived().TraverseObjCIvarRefExpr(static_cast<ObjCIvarRefExpr *>(S)));
case Stmt::ObjCMessageExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCMessageExpr), decltype(&Derived::TraverseObjCMessageExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCMessageExpr), decltype(&Derived::TraverseObjCMessageExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCMessageExpr(static_cast<ObjCMessageExpr *>(S), Queue) : getDerived().TraverseObjCMessageExpr(static_cast<ObjCMessageExpr *>(S)));
case Stmt::ObjCPropertyRefExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCPropertyRefExpr), decltype(&Derived::TraverseObjCPropertyRefExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCPropertyRefExpr), decltype(&Derived::TraverseObjCPropertyRefExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCPropertyRefExpr(static_cast<ObjCPropertyRefExpr *>(S), Queue) : getDerived().TraverseObjCPropertyRefExpr(static_cast<ObjCPropertyRefExpr *>(S)));
case Stmt::ObjCProtocolExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCProtocolExpr), decltype(&Derived::TraverseObjCProtocolExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCProtocolExpr), decltype(&Derived::TraverseObjCProtocolExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCProtocolExpr(static_cast<ObjCProtocolExpr *>(S), Queue) : getDerived().TraverseObjCProtocolExpr(static_cast<ObjCProtocolExpr *>(S)));
case Stmt::ObjCSelectorExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCSelectorExpr), decltype(&Derived::TraverseObjCSelectorExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCSelectorExpr), decltype(&Derived::TraverseObjCSelectorExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCSelectorExpr(static_cast<ObjCSelectorExpr *>(S), Queue) : getDerived().TraverseObjCSelectorExpr(static_cast<ObjCSelectorExpr *>(S)));
case Stmt::ObjCStringLiteralClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCStringLiteral), decltype(&Derived::TraverseObjCStringLiteral)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCStringLiteral), decltype(&Derived::TraverseObjCStringLiteral)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCStringLiteral(static_cast<ObjCStringLiteral *>(S), Queue) : getDerived().TraverseObjCStringLiteral(static_cast<ObjCStringLiteral *>(S)));
case Stmt::ObjCSubscriptRefExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCSubscriptRefExpr), decltype(&Derived::TraverseObjCSubscriptRefExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCSubscriptRefExpr), decltype(&Derived::TraverseObjCSubscriptRefExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCSubscriptRefExpr(static_cast<ObjCSubscriptRefExpr *>(S), Queue) : getDerived().TraverseObjCSubscriptRefExpr(static_cast<ObjCSubscriptRefExpr *>(S)));
case Stmt::OffsetOfExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOffsetOfExpr), decltype(&Derived::TraverseOffsetOfExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOffsetOfExpr), decltype(&Derived::TraverseOffsetOfExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOffsetOfExpr(static_cast<OffsetOfExpr *>(S), Queue) : getDerived().TraverseOffsetOfExpr(static_cast<OffsetOfExpr *>(S)));
case Stmt::OpaqueValueExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOpaqueValueExpr), decltype(&Derived::TraverseOpaqueValueExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOpaqueValueExpr), decltype(&Derived::TraverseOpaqueValueExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOpaqueValueExpr(static_cast<OpaqueValueExpr *>(S), Queue) : getDerived().TraverseOpaqueValueExpr(static_cast<OpaqueValueExpr *>(S)));
case Stmt::UnresolvedLookupExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseUnresolvedLookupExpr), decltype(&Derived::TraverseUnresolvedLookupExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseUnresolvedLookupExpr), decltype(&Derived::TraverseUnresolvedLookupExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseUnresolvedLookupExpr(static_cast<UnresolvedLookupExpr *>(S), Queue) : getDerived().TraverseUnresolvedLookupExpr(static_cast<UnresolvedLookupExpr *>(S)));
case Stmt::UnresolvedMemberExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseUnresolvedMemberExpr), decltype(&Derived::TraverseUnresolvedMemberExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseUnresolvedMemberExpr), decltype(&Derived::TraverseUnresolvedMemberExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseUnresolvedMemberExpr(static_cast<UnresolvedMemberExpr *>(S), Queue) : getDerived().TraverseUnresolvedMemberExpr(static_cast<UnresolvedMemberExpr *>(S)));
case Stmt::PackExpansionExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraversePackExpansionExpr), decltype(&Derived::TraversePackExpansionExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraversePackExpansionExpr), decltype(&Derived::TraversePackExpansionExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraversePackExpansionExpr(static_cast<PackExpansionExpr *>(S), Queue) : getDerived().TraversePackExpansionExpr(static_cast<PackExpansionExpr *>(S)));
case Stmt::ParenExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseParenExpr), decltype(&Derived::TraverseParenExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseParenExpr), decltype(&Derived::TraverseParenExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseParenExpr(static_cast<ParenExpr *>(S), Queue) : getDerived().TraverseParenExpr(static_cast<ParenExpr *>(S)));
case Stmt::ParenListExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseParenListExpr), decltype(&Derived::TraverseParenListExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseParenListExpr), decltype(&Derived::TraverseParenListExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseParenListExpr(static_cast<ParenListExpr *>(S), Queue) : getDerived().TraverseParenListExpr(static_cast<ParenListExpr *>(S)));
case Stmt::PredefinedExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraversePredefinedExpr), decltype(&Derived::TraversePredefinedExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraversePredefinedExpr), decltype(&Derived::TraversePredefinedExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraversePredefinedExpr(static_cast<PredefinedExpr *>(S), Queue) : getDerived().TraversePredefinedExpr(static_cast<PredefinedExpr *>(S)));
case Stmt::PseudoObjectExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraversePseudoObjectExpr), decltype(&Derived::TraversePseudoObjectExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraversePseudoObjectExpr), decltype(&Derived::TraversePseudoObjectExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraversePseudoObjectExpr(static_cast<PseudoObjectExpr *>(S), Queue) : getDerived().TraversePseudoObjectExpr(static_cast<PseudoObjectExpr *>(S)));
case Stmt::RecoveryExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseRecoveryExpr), decltype(&Derived::TraverseRecoveryExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseRecoveryExpr), decltype(&Derived::TraverseRecoveryExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseRecoveryExpr(static_cast<RecoveryExpr *>(S), Queue) : getDerived().TraverseRecoveryExpr(static_cast<RecoveryExpr *>(S)));
case Stmt::RequiresExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseRequiresExpr), decltype(&Derived::TraverseRequiresExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseRequiresExpr), decltype(&Derived::TraverseRequiresExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseRequiresExpr(static_cast<RequiresExpr *>(S), Queue) : getDerived().TraverseRequiresExpr(static_cast<RequiresExpr *>(S)));
case Stmt::SYCLUniqueStableNameExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSYCLUniqueStableNameExpr), decltype(&Derived::TraverseSYCLUniqueStableNameExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSYCLUniqueStableNameExpr), decltype(&Derived::TraverseSYCLUniqueStableNameExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseSYCLUniqueStableNameExpr(static_cast<SYCLUniqueStableNameExpr *>(S), Queue) : getDerived().TraverseSYCLUniqueStableNameExpr(static_cast<SYCLUniqueStableNameExpr *>(S)));
case Stmt::ShuffleVectorExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseShuffleVectorExpr), decltype(&Derived::TraverseShuffleVectorExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseShuffleVectorExpr), decltype(&Derived::TraverseShuffleVectorExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseShuffleVectorExpr(static_cast<ShuffleVectorExpr *>(S), Queue) : getDerived().TraverseShuffleVectorExpr(static_cast<ShuffleVectorExpr *>(S)));
case Stmt::SizeOfPackExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSizeOfPackExpr), decltype(&Derived::TraverseSizeOfPackExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSizeOfPackExpr), decltype(&Derived::TraverseSizeOfPackExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseSizeOfPackExpr(static_cast<SizeOfPackExpr *>(S), Queue) : getDerived().TraverseSizeOfPackExpr(static_cast<SizeOfPackExpr *>(S)));
case Stmt::SourceLocExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSourceLocExpr), decltype(&Derived::TraverseSourceLocExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSourceLocExpr), decltype(&Derived::TraverseSourceLocExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseSourceLocExpr(static_cast<SourceLocExpr *>(S), Queue) : getDerived().TraverseSourceLocExpr(static_cast<SourceLocExpr *>(S)));
case Stmt::StmtExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmtExpr), decltype(&Derived::TraverseStmtExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmtExpr), decltype(&Derived::TraverseStmtExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmtExpr(static_cast<StmtExpr *>(S), Queue) : getDerived().TraverseStmtExpr(static_cast<StmtExpr *>(S)));
case Stmt::StringLiteralClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStringLiteral), decltype(&Derived::TraverseStringLiteral)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStringLiteral), decltype(&Derived::TraverseStringLiteral)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStringLiteral(static_cast<StringLiteral *>(S), Queue) : getDerived().TraverseStringLiteral(static_cast<StringLiteral *>(S)));
case Stmt::SubstNonTypeTemplateParmExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSubstNonTypeTemplateParmExpr), decltype(&Derived::TraverseSubstNonTypeTemplateParmExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSubstNonTypeTemplateParmExpr), decltype(&Derived::TraverseSubstNonTypeTemplateParmExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseSubstNonTypeTemplateParmExpr(static_cast<SubstNonTypeTemplateParmExpr *>(S), Queue) : getDerived().TraverseSubstNonTypeTemplateParmExpr(static_cast<SubstNonTypeTemplateParmExpr *>(S)));
case Stmt::SubstNonTypeTemplateParmPackExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSubstNonTypeTemplateParmPackExpr), decltype(&Derived::TraverseSubstNonTypeTemplateParmPackExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSubstNonTypeTemplateParmPackExpr), decltype(&Derived::TraverseSubstNonTypeTemplateParmPackExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseSubstNonTypeTemplateParmPackExpr(static_cast<SubstNonTypeTemplateParmPackExpr *>(S), Queue) : getDerived().TraverseSubstNonTypeTemplateParmPackExpr(static_cast<SubstNonTypeTemplateParmPackExpr *>(S)));
case Stmt::TypeTraitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseTypeTraitExpr), decltype(&Derived::TraverseTypeTraitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseTypeTraitExpr), decltype(&Derived::TraverseTypeTraitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseTypeTraitExpr(static_cast<TypeTraitExpr *>(S), Queue) : getDerived().TraverseTypeTraitExpr(static_cast<TypeTraitExpr *>(S)));
case Stmt::TypoExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseTypoExpr), decltype(&Derived::TraverseTypoExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseTypoExpr), decltype(&Derived::TraverseTypoExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseTypoExpr(static_cast<TypoExpr *>(S), Queue) : getDerived().TraverseTypoExpr(static_cast<TypoExpr *>(S)));
case Stmt::UnaryExprOrTypeTraitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseUnaryExprOrTypeTraitExpr), decltype(&Derived::TraverseUnaryExprOrTypeTraitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseUnaryExprOrTypeTraitExpr), decltype(&Derived::TraverseUnaryExprOrTypeTraitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseUnaryExprOrTypeTraitExpr(static_cast<UnaryExprOrTypeTraitExpr *>(S), Queue) : getDerived().TraverseUnaryExprOrTypeTraitExpr(static_cast<UnaryExprOrTypeTraitExpr *>(S)));
case Stmt::UnaryOperatorClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseUnaryOperator), decltype(&Derived::TraverseUnaryOperator)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseUnaryOperator), decltype(&Derived::TraverseUnaryOperator)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseUnaryOperator(static_cast<UnaryOperator *>(S), Queue) : getDerived().TraverseUnaryOperator(static_cast<UnaryOperator *>(S)));
case Stmt::VAArgExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseVAArgExpr), decltype(&Derived::TraverseVAArgExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseVAArgExpr), decltype(&Derived::TraverseVAArgExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseVAArgExpr(static_cast<VAArgExpr *>(S), Queue) : getDerived().TraverseVAArgExpr(static_cast<VAArgExpr *>(S)));
case Stmt::LabelStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseLabelStmt), decltype(&Derived::TraverseLabelStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseLabelStmt), decltype(&Derived::TraverseLabelStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseLabelStmt(static_cast<LabelStmt *>(S), Queue) : getDerived().TraverseLabelStmt(static_cast<LabelStmt *>(S)));
case Stmt::WhileStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseWhileStmt), decltype(&Derived::TraverseWhileStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseWhileStmt), decltype(&Derived::TraverseWhileStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseWhileStmt(static_cast<WhileStmt *>(S), Queue) : getDerived().TraverseWhileStmt(static_cast<WhileStmt *>(S)));
 }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::PostVisitStmt(Stmt *S) {
  switch (S->getStmtClass()) {
  case Stmt::NoStmtClass:
    break;
case Stmt::GCCAsmStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseGCCAsmStmt, &Derived::TraverseGCCAsmStmt)) { do { if (!getDerived().WalkUpFromGCCAsmStmt(static_cast<GCCAsmStmt *>(S))) return false; } while (false); } break;
case Stmt::MSAsmStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseMSAsmStmt, &Derived::TraverseMSAsmStmt)) { do { if (!getDerived().WalkUpFromMSAsmStmt(static_cast<MSAsmStmt *>(S))) return false; } while (false); } break;
case Stmt::BreakStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseBreakStmt, &Derived::TraverseBreakStmt)) { do { if (!getDerived().WalkUpFromBreakStmt(static_cast<BreakStmt *>(S))) return false; } while (false); } break;
case Stmt::CXXCatchStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXCatchStmt, &Derived::TraverseCXXCatchStmt)) { do { if (!getDerived().WalkUpFromCXXCatchStmt(static_cast<CXXCatchStmt *>(S))) return false; } while (false); } break;
case Stmt::CXXForRangeStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXForRangeStmt, &Derived::TraverseCXXForRangeStmt)) { do { if (!getDerived().WalkUpFromCXXForRangeStmt(static_cast<CXXForRangeStmt *>(S))) return false; } while (false); } break;
case Stmt::CXXTryStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXTryStmt, &Derived::TraverseCXXTryStmt)) { do { if (!getDerived().WalkUpFromCXXTryStmt(static_cast<CXXTryStmt *>(S))) return false; } while (false); } break;
case Stmt::CapturedStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCapturedStmt, &Derived::TraverseCapturedStmt)) { do { if (!getDerived().WalkUpFromCapturedStmt(static_cast<CapturedStmt *>(S))) return false; } while (false); } break;
case Stmt::CompoundStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCompoundStmt, &Derived::TraverseCompoundStmt)) { do { if (!getDerived().WalkUpFromCompoundStmt(static_cast<CompoundStmt *>(S))) return false; } while (false); } break;
case Stmt::ContinueStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseContinueStmt, &Derived::TraverseContinueStmt)) { do { if (!getDerived().WalkUpFromContinueStmt(static_cast<ContinueStmt *>(S))) return false; } while (false); } break;
case Stmt::CoreturnStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCoreturnStmt, &Derived::TraverseCoreturnStmt)) { do { if (!getDerived().WalkUpFromCoreturnStmt(static_cast<CoreturnStmt *>(S))) return false; } while (false); } break;
case Stmt::CoroutineBodyStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCoroutineBodyStmt, &Derived::TraverseCoroutineBodyStmt)) { do { if (!getDerived().WalkUpFromCoroutineBodyStmt(static_cast<CoroutineBodyStmt *>(S))) return false; } while (false); } break;
case Stmt::DeclStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseDeclStmt, &Derived::TraverseDeclStmt)) { do { if (!getDerived().WalkUpFromDeclStmt(static_cast<DeclStmt *>(S))) return false; } while (false); } break;
case Stmt::DoStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseDoStmt, &Derived::TraverseDoStmt)) { do { if (!getDerived().WalkUpFromDoStmt(static_cast<DoStmt *>(S))) return false; } while (false); } break;
case Stmt::ForStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseForStmt, &Derived::TraverseForStmt)) { do { if (!getDerived().WalkUpFromForStmt(static_cast<ForStmt *>(S))) return false; } while (false); } break;
case Stmt::GotoStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseGotoStmt, &Derived::TraverseGotoStmt)) { do { if (!getDerived().WalkUpFromGotoStmt(static_cast<GotoStmt *>(S))) return false; } while (false); } break;
case Stmt::IfStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseIfStmt, &Derived::TraverseIfStmt)) { do { if (!getDerived().WalkUpFromIfStmt(static_cast<IfStmt *>(S))) return false; } while (false); } break;
case Stmt::IndirectGotoStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseIndirectGotoStmt, &Derived::TraverseIndirectGotoStmt)) { do { if (!getDerived().WalkUpFromIndirectGotoStmt(static_cast<IndirectGotoStmt *>(S))) return false; } while (false); } break;
case Stmt::MSDependentExistsStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseMSDependentExistsStmt, &Derived::TraverseMSDependentExistsStmt)) { do { if (!getDerived().WalkUpFromMSDependentExistsStmt(static_cast<MSDependentExistsStmt *>(S))) return false; } while (false); } break;
case Stmt::NullStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseNullStmt, &Derived::TraverseNullStmt)) { do { if (!getDerived().WalkUpFromNullStmt(static_cast<NullStmt *>(S))) return false; } while (false); } break;
case Stmt::OMPCanonicalLoopClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPCanonicalLoop, &Derived::TraverseOMPCanonicalLoop)) { do { if (!getDerived().WalkUpFromOMPCanonicalLoop(static_cast<OMPCanonicalLoop *>(S))) return false; } while (false); } break;
case Stmt::OMPAtomicDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPAtomicDirective, &Derived::TraverseOMPAtomicDirective)) { do { if (!getDerived().WalkUpFromOMPAtomicDirective(static_cast<OMPAtomicDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPBarrierDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPBarrierDirective, &Derived::TraverseOMPBarrierDirective)) { do { if (!getDerived().WalkUpFromOMPBarrierDirective(static_cast<OMPBarrierDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPCancelDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPCancelDirective, &Derived::TraverseOMPCancelDirective)) { do { if (!getDerived().WalkUpFromOMPCancelDirective(static_cast<OMPCancelDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPCancellationPointDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPCancellationPointDirective, &Derived::TraverseOMPCancellationPointDirective)) { do { if (!getDerived().WalkUpFromOMPCancellationPointDirective(static_cast<OMPCancellationPointDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPCriticalDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPCriticalDirective, &Derived::TraverseOMPCriticalDirective)) { do { if (!getDerived().WalkUpFromOMPCriticalDirective(static_cast<OMPCriticalDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPDepobjDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPDepobjDirective, &Derived::TraverseOMPDepobjDirective)) { do { if (!getDerived().WalkUpFromOMPDepobjDirective(static_cast<OMPDepobjDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPDispatchDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPDispatchDirective, &Derived::TraverseOMPDispatchDirective)) { do { if (!getDerived().WalkUpFromOMPDispatchDirective(static_cast<OMPDispatchDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPFlushDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPFlushDirective, &Derived::TraverseOMPFlushDirective)) { do { if (!getDerived().WalkUpFromOMPFlushDirective(static_cast<OMPFlushDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPInteropDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPInteropDirective, &Derived::TraverseOMPInteropDirective)) { do { if (!getDerived().WalkUpFromOMPInteropDirective(static_cast<OMPInteropDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPDistributeDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPDistributeDirective, &Derived::TraverseOMPDistributeDirective)) { do { if (!getDerived().WalkUpFromOMPDistributeDirective(static_cast<OMPDistributeDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPDistributeParallelForDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPDistributeParallelForDirective, &Derived::TraverseOMPDistributeParallelForDirective)) { do { if (!getDerived().WalkUpFromOMPDistributeParallelForDirective(static_cast<OMPDistributeParallelForDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPDistributeParallelForSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPDistributeParallelForSimdDirective, &Derived::TraverseOMPDistributeParallelForSimdDirective)) { do { if (!getDerived().WalkUpFromOMPDistributeParallelForSimdDirective(static_cast<OMPDistributeParallelForSimdDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPDistributeSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPDistributeSimdDirective, &Derived::TraverseOMPDistributeSimdDirective)) { do { if (!getDerived().WalkUpFromOMPDistributeSimdDirective(static_cast<OMPDistributeSimdDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPForDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPForDirective, &Derived::TraverseOMPForDirective)) { do { if (!getDerived().WalkUpFromOMPForDirective(static_cast<OMPForDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPForSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPForSimdDirective, &Derived::TraverseOMPForSimdDirective)) { do { if (!getDerived().WalkUpFromOMPForSimdDirective(static_cast<OMPForSimdDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPMasterTaskLoopDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPMasterTaskLoopDirective, &Derived::TraverseOMPMasterTaskLoopDirective)) { do { if (!getDerived().WalkUpFromOMPMasterTaskLoopDirective(static_cast<OMPMasterTaskLoopDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPMasterTaskLoopSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPMasterTaskLoopSimdDirective, &Derived::TraverseOMPMasterTaskLoopSimdDirective)) { do { if (!getDerived().WalkUpFromOMPMasterTaskLoopSimdDirective(static_cast<OMPMasterTaskLoopSimdDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPParallelForDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPParallelForDirective, &Derived::TraverseOMPParallelForDirective)) { do { if (!getDerived().WalkUpFromOMPParallelForDirective(static_cast<OMPParallelForDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPParallelForSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPParallelForSimdDirective, &Derived::TraverseOMPParallelForSimdDirective)) { do { if (!getDerived().WalkUpFromOMPParallelForSimdDirective(static_cast<OMPParallelForSimdDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPParallelMasterTaskLoopDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPParallelMasterTaskLoopDirective, &Derived::TraverseOMPParallelMasterTaskLoopDirective)) { do { if (!getDerived().WalkUpFromOMPParallelMasterTaskLoopDirective(static_cast<OMPParallelMasterTaskLoopDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPParallelMasterTaskLoopSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPParallelMasterTaskLoopSimdDirective, &Derived::TraverseOMPParallelMasterTaskLoopSimdDirective)) { do { if (!getDerived().WalkUpFromOMPParallelMasterTaskLoopSimdDirective(static_cast<OMPParallelMasterTaskLoopSimdDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPSimdDirective, &Derived::TraverseOMPSimdDirective)) { do { if (!getDerived().WalkUpFromOMPSimdDirective(static_cast<OMPSimdDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTargetParallelForSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetParallelForSimdDirective, &Derived::TraverseOMPTargetParallelForSimdDirective)) { do { if (!getDerived().WalkUpFromOMPTargetParallelForSimdDirective(static_cast<OMPTargetParallelForSimdDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTargetSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetSimdDirective, &Derived::TraverseOMPTargetSimdDirective)) { do { if (!getDerived().WalkUpFromOMPTargetSimdDirective(static_cast<OMPTargetSimdDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTargetTeamsDistributeDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeDirective, &Derived::TraverseOMPTargetTeamsDistributeDirective)) { do { if (!getDerived().WalkUpFromOMPTargetTeamsDistributeDirective(static_cast<OMPTargetTeamsDistributeDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeParallelForDirective, &Derived::TraverseOMPTargetTeamsDistributeParallelForDirective)) { do { if (!getDerived().WalkUpFromOMPTargetTeamsDistributeParallelForDirective(static_cast<OMPTargetTeamsDistributeParallelForDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeParallelForSimdDirective, &Derived::TraverseOMPTargetTeamsDistributeParallelForSimdDirective)) { do { if (!getDerived().WalkUpFromOMPTargetTeamsDistributeParallelForSimdDirective(static_cast<OMPTargetTeamsDistributeParallelForSimdDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeSimdDirective, &Derived::TraverseOMPTargetTeamsDistributeSimdDirective)) { do { if (!getDerived().WalkUpFromOMPTargetTeamsDistributeSimdDirective(static_cast<OMPTargetTeamsDistributeSimdDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTaskLoopDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTaskLoopDirective, &Derived::TraverseOMPTaskLoopDirective)) { do { if (!getDerived().WalkUpFromOMPTaskLoopDirective(static_cast<OMPTaskLoopDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTaskLoopSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTaskLoopSimdDirective, &Derived::TraverseOMPTaskLoopSimdDirective)) { do { if (!getDerived().WalkUpFromOMPTaskLoopSimdDirective(static_cast<OMPTaskLoopSimdDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTeamsDistributeDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTeamsDistributeDirective, &Derived::TraverseOMPTeamsDistributeDirective)) { do { if (!getDerived().WalkUpFromOMPTeamsDistributeDirective(static_cast<OMPTeamsDistributeDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTeamsDistributeParallelForDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTeamsDistributeParallelForDirective, &Derived::TraverseOMPTeamsDistributeParallelForDirective)) { do { if (!getDerived().WalkUpFromOMPTeamsDistributeParallelForDirective(static_cast<OMPTeamsDistributeParallelForDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTeamsDistributeParallelForSimdDirective, &Derived::TraverseOMPTeamsDistributeParallelForSimdDirective)) { do { if (!getDerived().WalkUpFromOMPTeamsDistributeParallelForSimdDirective(static_cast<OMPTeamsDistributeParallelForSimdDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTeamsDistributeSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTeamsDistributeSimdDirective, &Derived::TraverseOMPTeamsDistributeSimdDirective)) { do { if (!getDerived().WalkUpFromOMPTeamsDistributeSimdDirective(static_cast<OMPTeamsDistributeSimdDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTileDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTileDirective, &Derived::TraverseOMPTileDirective)) { do { if (!getDerived().WalkUpFromOMPTileDirective(static_cast<OMPTileDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPUnrollDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPUnrollDirective, &Derived::TraverseOMPUnrollDirective)) { do { if (!getDerived().WalkUpFromOMPUnrollDirective(static_cast<OMPUnrollDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPMaskedDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPMaskedDirective, &Derived::TraverseOMPMaskedDirective)) { do { if (!getDerived().WalkUpFromOMPMaskedDirective(static_cast<OMPMaskedDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPMasterDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPMasterDirective, &Derived::TraverseOMPMasterDirective)) { do { if (!getDerived().WalkUpFromOMPMasterDirective(static_cast<OMPMasterDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPOrderedDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPOrderedDirective, &Derived::TraverseOMPOrderedDirective)) { do { if (!getDerived().WalkUpFromOMPOrderedDirective(static_cast<OMPOrderedDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPParallelDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPParallelDirective, &Derived::TraverseOMPParallelDirective)) { do { if (!getDerived().WalkUpFromOMPParallelDirective(static_cast<OMPParallelDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPParallelMasterDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPParallelMasterDirective, &Derived::TraverseOMPParallelMasterDirective)) { do { if (!getDerived().WalkUpFromOMPParallelMasterDirective(static_cast<OMPParallelMasterDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPParallelSectionsDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPParallelSectionsDirective, &Derived::TraverseOMPParallelSectionsDirective)) { do { if (!getDerived().WalkUpFromOMPParallelSectionsDirective(static_cast<OMPParallelSectionsDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPScanDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPScanDirective, &Derived::TraverseOMPScanDirective)) { do { if (!getDerived().WalkUpFromOMPScanDirective(static_cast<OMPScanDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPSectionDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPSectionDirective, &Derived::TraverseOMPSectionDirective)) { do { if (!getDerived().WalkUpFromOMPSectionDirective(static_cast<OMPSectionDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPSectionsDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPSectionsDirective, &Derived::TraverseOMPSectionsDirective)) { do { if (!getDerived().WalkUpFromOMPSectionsDirective(static_cast<OMPSectionsDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPSingleDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPSingleDirective, &Derived::TraverseOMPSingleDirective)) { do { if (!getDerived().WalkUpFromOMPSingleDirective(static_cast<OMPSingleDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTargetDataDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetDataDirective, &Derived::TraverseOMPTargetDataDirective)) { do { if (!getDerived().WalkUpFromOMPTargetDataDirective(static_cast<OMPTargetDataDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTargetDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetDirective, &Derived::TraverseOMPTargetDirective)) { do { if (!getDerived().WalkUpFromOMPTargetDirective(static_cast<OMPTargetDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTargetEnterDataDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetEnterDataDirective, &Derived::TraverseOMPTargetEnterDataDirective)) { do { if (!getDerived().WalkUpFromOMPTargetEnterDataDirective(static_cast<OMPTargetEnterDataDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTargetExitDataDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetExitDataDirective, &Derived::TraverseOMPTargetExitDataDirective)) { do { if (!getDerived().WalkUpFromOMPTargetExitDataDirective(static_cast<OMPTargetExitDataDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTargetParallelDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetParallelDirective, &Derived::TraverseOMPTargetParallelDirective)) { do { if (!getDerived().WalkUpFromOMPTargetParallelDirective(static_cast<OMPTargetParallelDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTargetParallelForDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetParallelForDirective, &Derived::TraverseOMPTargetParallelForDirective)) { do { if (!getDerived().WalkUpFromOMPTargetParallelForDirective(static_cast<OMPTargetParallelForDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTargetTeamsDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetTeamsDirective, &Derived::TraverseOMPTargetTeamsDirective)) { do { if (!getDerived().WalkUpFromOMPTargetTeamsDirective(static_cast<OMPTargetTeamsDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTargetUpdateDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetUpdateDirective, &Derived::TraverseOMPTargetUpdateDirective)) { do { if (!getDerived().WalkUpFromOMPTargetUpdateDirective(static_cast<OMPTargetUpdateDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTaskDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTaskDirective, &Derived::TraverseOMPTaskDirective)) { do { if (!getDerived().WalkUpFromOMPTaskDirective(static_cast<OMPTaskDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTaskgroupDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTaskgroupDirective, &Derived::TraverseOMPTaskgroupDirective)) { do { if (!getDerived().WalkUpFromOMPTaskgroupDirective(static_cast<OMPTaskgroupDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTaskwaitDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTaskwaitDirective, &Derived::TraverseOMPTaskwaitDirective)) { do { if (!getDerived().WalkUpFromOMPTaskwaitDirective(static_cast<OMPTaskwaitDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTaskyieldDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTaskyieldDirective, &Derived::TraverseOMPTaskyieldDirective)) { do { if (!getDerived().WalkUpFromOMPTaskyieldDirective(static_cast<OMPTaskyieldDirective *>(S))) return false; } while (false); } break;
case Stmt::OMPTeamsDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTeamsDirective, &Derived::TraverseOMPTeamsDirective)) { do { if (!getDerived().WalkUpFromOMPTeamsDirective(static_cast<OMPTeamsDirective *>(S))) return false; } while (false); } break;
case Stmt::ObjCAtCatchStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCAtCatchStmt, &Derived::TraverseObjCAtCatchStmt)) { do { if (!getDerived().WalkUpFromObjCAtCatchStmt(static_cast<ObjCAtCatchStmt *>(S))) return false; } while (false); } break;
case Stmt::ObjCAtFinallyStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCAtFinallyStmt, &Derived::TraverseObjCAtFinallyStmt)) { do { if (!getDerived().WalkUpFromObjCAtFinallyStmt(static_cast<ObjCAtFinallyStmt *>(S))) return false; } while (false); } break;
case Stmt::ObjCAtSynchronizedStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCAtSynchronizedStmt, &Derived::TraverseObjCAtSynchronizedStmt)) { do { if (!getDerived().WalkUpFromObjCAtSynchronizedStmt(static_cast<ObjCAtSynchronizedStmt *>(S))) return false; } while (false); } break;
case Stmt::ObjCAtThrowStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCAtThrowStmt, &Derived::TraverseObjCAtThrowStmt)) { do { if (!getDerived().WalkUpFromObjCAtThrowStmt(static_cast<ObjCAtThrowStmt *>(S))) return false; } while (false); } break;
case Stmt::ObjCAtTryStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCAtTryStmt, &Derived::TraverseObjCAtTryStmt)) { do { if (!getDerived().WalkUpFromObjCAtTryStmt(static_cast<ObjCAtTryStmt *>(S))) return false; } while (false); } break;
case Stmt::ObjCAutoreleasePoolStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCAutoreleasePoolStmt, &Derived::TraverseObjCAutoreleasePoolStmt)) { do { if (!getDerived().WalkUpFromObjCAutoreleasePoolStmt(static_cast<ObjCAutoreleasePoolStmt *>(S))) return false; } while (false); } break;
case Stmt::ObjCForCollectionStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCForCollectionStmt, &Derived::TraverseObjCForCollectionStmt)) { do { if (!getDerived().WalkUpFromObjCForCollectionStmt(static_cast<ObjCForCollectionStmt *>(S))) return false; } while (false); } break;
case Stmt::ReturnStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseReturnStmt, &Derived::TraverseReturnStmt)) { do { if (!getDerived().WalkUpFromReturnStmt(static_cast<ReturnStmt *>(S))) return false; } while (false); } break;
case Stmt::SEHExceptStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseSEHExceptStmt, &Derived::TraverseSEHExceptStmt)) { do { if (!getDerived().WalkUpFromSEHExceptStmt(static_cast<SEHExceptStmt *>(S))) return false; } while (false); } break;
case Stmt::SEHFinallyStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseSEHFinallyStmt, &Derived::TraverseSEHFinallyStmt)) { do { if (!getDerived().WalkUpFromSEHFinallyStmt(static_cast<SEHFinallyStmt *>(S))) return false; } while (false); } break;
case Stmt::SEHLeaveStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseSEHLeaveStmt, &Derived::TraverseSEHLeaveStmt)) { do { if (!getDerived().WalkUpFromSEHLeaveStmt(static_cast<SEHLeaveStmt *>(S))) return false; } while (false); } break;
case Stmt::SEHTryStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseSEHTryStmt, &Derived::TraverseSEHTryStmt)) { do { if (!getDerived().WalkUpFromSEHTryStmt(static_cast<SEHTryStmt *>(S))) return false; } while (false); } break;
case Stmt::CaseStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCaseStmt, &Derived::TraverseCaseStmt)) { do { if (!getDerived().WalkUpFromCaseStmt(static_cast<CaseStmt *>(S))) return false; } while (false); } break;
case Stmt::DefaultStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseDefaultStmt, &Derived::TraverseDefaultStmt)) { do { if (!getDerived().WalkUpFromDefaultStmt(static_cast<DefaultStmt *>(S))) return false; } while (false); } break;
case Stmt::SwitchStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseSwitchStmt, &Derived::TraverseSwitchStmt)) { do { if (!getDerived().WalkUpFromSwitchStmt(static_cast<SwitchStmt *>(S))) return false; } while (false); } break;
case Stmt::AttributedStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseAttributedStmt, &Derived::TraverseAttributedStmt)) { do { if (!getDerived().WalkUpFromAttributedStmt(static_cast<AttributedStmt *>(S))) return false; } while (false); } break;
case Stmt::BinaryConditionalOperatorClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseBinaryConditionalOperator, &Derived::TraverseBinaryConditionalOperator)) { do { if (!getDerived().WalkUpFromBinaryConditionalOperator(static_cast<BinaryConditionalOperator *>(S))) return false; } while (false); } break;
case Stmt::ConditionalOperatorClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseConditionalOperator, &Derived::TraverseConditionalOperator)) { do { if (!getDerived().WalkUpFromConditionalOperator(static_cast<ConditionalOperator *>(S))) return false; } while (false); } break;
case Stmt::AddrLabelExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseAddrLabelExpr, &Derived::TraverseAddrLabelExpr)) { do { if (!getDerived().WalkUpFromAddrLabelExpr(static_cast<AddrLabelExpr *>(S))) return false; } while (false); } break;
case Stmt::ArrayInitIndexExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseArrayInitIndexExpr, &Derived::TraverseArrayInitIndexExpr)) { do { if (!getDerived().WalkUpFromArrayInitIndexExpr(static_cast<ArrayInitIndexExpr *>(S))) return false; } while (false); } break;
case Stmt::ArrayInitLoopExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseArrayInitLoopExpr, &Derived::TraverseArrayInitLoopExpr)) { do { if (!getDerived().WalkUpFromArrayInitLoopExpr(static_cast<ArrayInitLoopExpr *>(S))) return false; } while (false); } break;
case Stmt::ArraySubscriptExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseArraySubscriptExpr, &Derived::TraverseArraySubscriptExpr)) { do { if (!getDerived().WalkUpFromArraySubscriptExpr(static_cast<ArraySubscriptExpr *>(S))) return false; } while (false); } break;
case Stmt::ArrayTypeTraitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseArrayTypeTraitExpr, &Derived::TraverseArrayTypeTraitExpr)) { do { if (!getDerived().WalkUpFromArrayTypeTraitExpr(static_cast<ArrayTypeTraitExpr *>(S))) return false; } while (false); } break;
case Stmt::AsTypeExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseAsTypeExpr, &Derived::TraverseAsTypeExpr)) { do { if (!getDerived().WalkUpFromAsTypeExpr(static_cast<AsTypeExpr *>(S))) return false; } while (false); } break;
case Stmt::AtomicExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseAtomicExpr, &Derived::TraverseAtomicExpr)) { do { if (!getDerived().WalkUpFromAtomicExpr(static_cast<AtomicExpr *>(S))) return false; } while (false); } break;
case Stmt::BinaryOperatorClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseBinaryOperator, &Derived::TraverseBinaryOperator)) { do { if (!getDerived().WalkUpFromBinaryOperator(static_cast<BinaryOperator *>(S))) return false; } while (false); } break;
case Stmt::CompoundAssignOperatorClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCompoundAssignOperator, &Derived::TraverseCompoundAssignOperator)) { do { if (!getDerived().WalkUpFromCompoundAssignOperator(static_cast<CompoundAssignOperator *>(S))) return false; } while (false); } break;
case Stmt::BlockExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseBlockExpr, &Derived::TraverseBlockExpr)) { do { if (!getDerived().WalkUpFromBlockExpr(static_cast<BlockExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXBindTemporaryExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXBindTemporaryExpr, &Derived::TraverseCXXBindTemporaryExpr)) { do { if (!getDerived().WalkUpFromCXXBindTemporaryExpr(static_cast<CXXBindTemporaryExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXBoolLiteralExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXBoolLiteralExpr, &Derived::TraverseCXXBoolLiteralExpr)) { do { if (!getDerived().WalkUpFromCXXBoolLiteralExpr(static_cast<CXXBoolLiteralExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXConstructExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXConstructExpr, &Derived::TraverseCXXConstructExpr)) { do { if (!getDerived().WalkUpFromCXXConstructExpr(static_cast<CXXConstructExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXTemporaryObjectExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXTemporaryObjectExpr, &Derived::TraverseCXXTemporaryObjectExpr)) { do { if (!getDerived().WalkUpFromCXXTemporaryObjectExpr(static_cast<CXXTemporaryObjectExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXDefaultArgExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXDefaultArgExpr, &Derived::TraverseCXXDefaultArgExpr)) { do { if (!getDerived().WalkUpFromCXXDefaultArgExpr(static_cast<CXXDefaultArgExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXDefaultInitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXDefaultInitExpr, &Derived::TraverseCXXDefaultInitExpr)) { do { if (!getDerived().WalkUpFromCXXDefaultInitExpr(static_cast<CXXDefaultInitExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXDeleteExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXDeleteExpr, &Derived::TraverseCXXDeleteExpr)) { do { if (!getDerived().WalkUpFromCXXDeleteExpr(static_cast<CXXDeleteExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXDependentScopeMemberExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXDependentScopeMemberExpr, &Derived::TraverseCXXDependentScopeMemberExpr)) { do { if (!getDerived().WalkUpFromCXXDependentScopeMemberExpr(static_cast<CXXDependentScopeMemberExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXFoldExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXFoldExpr, &Derived::TraverseCXXFoldExpr)) { do { if (!getDerived().WalkUpFromCXXFoldExpr(static_cast<CXXFoldExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXInheritedCtorInitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXInheritedCtorInitExpr, &Derived::TraverseCXXInheritedCtorInitExpr)) { do { if (!getDerived().WalkUpFromCXXInheritedCtorInitExpr(static_cast<CXXInheritedCtorInitExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXNewExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXNewExpr, &Derived::TraverseCXXNewExpr)) { do { if (!getDerived().WalkUpFromCXXNewExpr(static_cast<CXXNewExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXNoexceptExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXNoexceptExpr, &Derived::TraverseCXXNoexceptExpr)) { do { if (!getDerived().WalkUpFromCXXNoexceptExpr(static_cast<CXXNoexceptExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXNullPtrLiteralExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXNullPtrLiteralExpr, &Derived::TraverseCXXNullPtrLiteralExpr)) { do { if (!getDerived().WalkUpFromCXXNullPtrLiteralExpr(static_cast<CXXNullPtrLiteralExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXPseudoDestructorExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXPseudoDestructorExpr, &Derived::TraverseCXXPseudoDestructorExpr)) { do { if (!getDerived().WalkUpFromCXXPseudoDestructorExpr(static_cast<CXXPseudoDestructorExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXRewrittenBinaryOperatorClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXRewrittenBinaryOperator, &Derived::TraverseCXXRewrittenBinaryOperator)) { do { if (!getDerived().WalkUpFromCXXRewrittenBinaryOperator(static_cast<CXXRewrittenBinaryOperator *>(S))) return false; } while (false); } break;
case Stmt::CXXScalarValueInitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXScalarValueInitExpr, &Derived::TraverseCXXScalarValueInitExpr)) { do { if (!getDerived().WalkUpFromCXXScalarValueInitExpr(static_cast<CXXScalarValueInitExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXStdInitializerListExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXStdInitializerListExpr, &Derived::TraverseCXXStdInitializerListExpr)) { do { if (!getDerived().WalkUpFromCXXStdInitializerListExpr(static_cast<CXXStdInitializerListExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXThisExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXThisExpr, &Derived::TraverseCXXThisExpr)) { do { if (!getDerived().WalkUpFromCXXThisExpr(static_cast<CXXThisExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXThrowExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXThrowExpr, &Derived::TraverseCXXThrowExpr)) { do { if (!getDerived().WalkUpFromCXXThrowExpr(static_cast<CXXThrowExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXTypeidExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXTypeidExpr, &Derived::TraverseCXXTypeidExpr)) { do { if (!getDerived().WalkUpFromCXXTypeidExpr(static_cast<CXXTypeidExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXUnresolvedConstructExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXUnresolvedConstructExpr, &Derived::TraverseCXXUnresolvedConstructExpr)) { do { if (!getDerived().WalkUpFromCXXUnresolvedConstructExpr(static_cast<CXXUnresolvedConstructExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXUuidofExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXUuidofExpr, &Derived::TraverseCXXUuidofExpr)) { do { if (!getDerived().WalkUpFromCXXUuidofExpr(static_cast<CXXUuidofExpr *>(S))) return false; } while (false); } break;
case Stmt::CallExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCallExpr, &Derived::TraverseCallExpr)) { do { if (!getDerived().WalkUpFromCallExpr(static_cast<CallExpr *>(S))) return false; } while (false); } break;
case Stmt::CUDAKernelCallExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCUDAKernelCallExpr, &Derived::TraverseCUDAKernelCallExpr)) { do { if (!getDerived().WalkUpFromCUDAKernelCallExpr(static_cast<CUDAKernelCallExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXMemberCallExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXMemberCallExpr, &Derived::TraverseCXXMemberCallExpr)) { do { if (!getDerived().WalkUpFromCXXMemberCallExpr(static_cast<CXXMemberCallExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXOperatorCallExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXOperatorCallExpr, &Derived::TraverseCXXOperatorCallExpr)) { do { if (!getDerived().WalkUpFromCXXOperatorCallExpr(static_cast<CXXOperatorCallExpr *>(S))) return false; } while (false); } break;
case Stmt::UserDefinedLiteralClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseUserDefinedLiteral, &Derived::TraverseUserDefinedLiteral)) { do { if (!getDerived().WalkUpFromUserDefinedLiteral(static_cast<UserDefinedLiteral *>(S))) return false; } while (false); } break;
case Stmt::BuiltinBitCastExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseBuiltinBitCastExpr, &Derived::TraverseBuiltinBitCastExpr)) { do { if (!getDerived().WalkUpFromBuiltinBitCastExpr(static_cast<BuiltinBitCastExpr *>(S))) return false; } while (false); } break;
case Stmt::CStyleCastExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCStyleCastExpr, &Derived::TraverseCStyleCastExpr)) { do { if (!getDerived().WalkUpFromCStyleCastExpr(static_cast<CStyleCastExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXFunctionalCastExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXFunctionalCastExpr, &Derived::TraverseCXXFunctionalCastExpr)) { do { if (!getDerived().WalkUpFromCXXFunctionalCastExpr(static_cast<CXXFunctionalCastExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXAddrspaceCastExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXAddrspaceCastExpr, &Derived::TraverseCXXAddrspaceCastExpr)) { do { if (!getDerived().WalkUpFromCXXAddrspaceCastExpr(static_cast<CXXAddrspaceCastExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXConstCastExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXConstCastExpr, &Derived::TraverseCXXConstCastExpr)) { do { if (!getDerived().WalkUpFromCXXConstCastExpr(static_cast<CXXConstCastExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXDynamicCastExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXDynamicCastExpr, &Derived::TraverseCXXDynamicCastExpr)) { do { if (!getDerived().WalkUpFromCXXDynamicCastExpr(static_cast<CXXDynamicCastExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXReinterpretCastExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXReinterpretCastExpr, &Derived::TraverseCXXReinterpretCastExpr)) { do { if (!getDerived().WalkUpFromCXXReinterpretCastExpr(static_cast<CXXReinterpretCastExpr *>(S))) return false; } while (false); } break;
case Stmt::CXXStaticCastExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXStaticCastExpr, &Derived::TraverseCXXStaticCastExpr)) { do { if (!getDerived().WalkUpFromCXXStaticCastExpr(static_cast<CXXStaticCastExpr *>(S))) return false; } while (false); } break;
case Stmt::ObjCBridgedCastExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCBridgedCastExpr, &Derived::TraverseObjCBridgedCastExpr)) { do { if (!getDerived().WalkUpFromObjCBridgedCastExpr(static_cast<ObjCBridgedCastExpr *>(S))) return false; } while (false); } break;
case Stmt::ImplicitCastExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseImplicitCastExpr, &Derived::TraverseImplicitCastExpr)) { do { if (!getDerived().WalkUpFromImplicitCastExpr(static_cast<ImplicitCastExpr *>(S))) return false; } while (false); } break;
case Stmt::CharacterLiteralClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCharacterLiteral, &Derived::TraverseCharacterLiteral)) { do { if (!getDerived().WalkUpFromCharacterLiteral(static_cast<CharacterLiteral *>(S))) return false; } while (false); } break;
case Stmt::ChooseExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseChooseExpr, &Derived::TraverseChooseExpr)) { do { if (!getDerived().WalkUpFromChooseExpr(static_cast<ChooseExpr *>(S))) return false; } while (false); } break;
case Stmt::CompoundLiteralExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCompoundLiteralExpr, &Derived::TraverseCompoundLiteralExpr)) { do { if (!getDerived().WalkUpFromCompoundLiteralExpr(static_cast<CompoundLiteralExpr *>(S))) return false; } while (false); } break;
case Stmt::ConceptSpecializationExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseConceptSpecializationExpr, &Derived::TraverseConceptSpecializationExpr)) { do { if (!getDerived().WalkUpFromConceptSpecializationExpr(static_cast<ConceptSpecializationExpr *>(S))) return false; } while (false); } break;
case Stmt::ConvertVectorExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseConvertVectorExpr, &Derived::TraverseConvertVectorExpr)) { do { if (!getDerived().WalkUpFromConvertVectorExpr(static_cast<ConvertVectorExpr *>(S))) return false; } while (false); } break;
case Stmt::CoawaitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCoawaitExpr, &Derived::TraverseCoawaitExpr)) { do { if (!getDerived().WalkUpFromCoawaitExpr(static_cast<CoawaitExpr *>(S))) return false; } while (false); } break;
case Stmt::CoyieldExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCoyieldExpr, &Derived::TraverseCoyieldExpr)) { do { if (!getDerived().WalkUpFromCoyieldExpr(static_cast<CoyieldExpr *>(S))) return false; } while (false); } break;
case Stmt::DeclRefExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseDeclRefExpr, &Derived::TraverseDeclRefExpr)) { do { if (!getDerived().WalkUpFromDeclRefExpr(static_cast<DeclRefExpr *>(S))) return false; } while (false); } break;
case Stmt::DependentCoawaitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseDependentCoawaitExpr, &Derived::TraverseDependentCoawaitExpr)) { do { if (!getDerived().WalkUpFromDependentCoawaitExpr(static_cast<DependentCoawaitExpr *>(S))) return false; } while (false); } break;
case Stmt::DependentScopeDeclRefExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseDependentScopeDeclRefExpr, &Derived::TraverseDependentScopeDeclRefExpr)) { do { if (!getDerived().WalkUpFromDependentScopeDeclRefExpr(static_cast<DependentScopeDeclRefExpr *>(S))) return false; } while (false); } break;
case Stmt::DesignatedInitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseDesignatedInitExpr, &Derived::TraverseDesignatedInitExpr)) { do { if (!getDerived().WalkUpFromDesignatedInitExpr(static_cast<DesignatedInitExpr *>(S))) return false; } while (false); } break;
case Stmt::DesignatedInitUpdateExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseDesignatedInitUpdateExpr, &Derived::TraverseDesignatedInitUpdateExpr)) { do { if (!getDerived().WalkUpFromDesignatedInitUpdateExpr(static_cast<DesignatedInitUpdateExpr *>(S))) return false; } while (false); } break;
case Stmt::ExpressionTraitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseExpressionTraitExpr, &Derived::TraverseExpressionTraitExpr)) { do { if (!getDerived().WalkUpFromExpressionTraitExpr(static_cast<ExpressionTraitExpr *>(S))) return false; } while (false); } break;
case Stmt::ExtVectorElementExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseExtVectorElementExpr, &Derived::TraverseExtVectorElementExpr)) { do { if (!getDerived().WalkUpFromExtVectorElementExpr(static_cast<ExtVectorElementExpr *>(S))) return false; } while (false); } break;
case Stmt::FixedPointLiteralClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseFixedPointLiteral, &Derived::TraverseFixedPointLiteral)) { do { if (!getDerived().WalkUpFromFixedPointLiteral(static_cast<FixedPointLiteral *>(S))) return false; } while (false); } break;
case Stmt::FloatingLiteralClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseFloatingLiteral, &Derived::TraverseFloatingLiteral)) { do { if (!getDerived().WalkUpFromFloatingLiteral(static_cast<FloatingLiteral *>(S))) return false; } while (false); } break;
case Stmt::ConstantExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseConstantExpr, &Derived::TraverseConstantExpr)) { do { if (!getDerived().WalkUpFromConstantExpr(static_cast<ConstantExpr *>(S))) return false; } while (false); } break;
case Stmt::ExprWithCleanupsClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseExprWithCleanups, &Derived::TraverseExprWithCleanups)) { do { if (!getDerived().WalkUpFromExprWithCleanups(static_cast<ExprWithCleanups *>(S))) return false; } while (false); } break;
case Stmt::FunctionParmPackExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseFunctionParmPackExpr, &Derived::TraverseFunctionParmPackExpr)) { do { if (!getDerived().WalkUpFromFunctionParmPackExpr(static_cast<FunctionParmPackExpr *>(S))) return false; } while (false); } break;
case Stmt::GNUNullExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseGNUNullExpr, &Derived::TraverseGNUNullExpr)) { do { if (!getDerived().WalkUpFromGNUNullExpr(static_cast<GNUNullExpr *>(S))) return false; } while (false); } break;
case Stmt::GenericSelectionExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseGenericSelectionExpr, &Derived::TraverseGenericSelectionExpr)) { do { if (!getDerived().WalkUpFromGenericSelectionExpr(static_cast<GenericSelectionExpr *>(S))) return false; } while (false); } break;
case Stmt::ImaginaryLiteralClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseImaginaryLiteral, &Derived::TraverseImaginaryLiteral)) { do { if (!getDerived().WalkUpFromImaginaryLiteral(static_cast<ImaginaryLiteral *>(S))) return false; } while (false); } break;
case Stmt::ImplicitValueInitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseImplicitValueInitExpr, &Derived::TraverseImplicitValueInitExpr)) { do { if (!getDerived().WalkUpFromImplicitValueInitExpr(static_cast<ImplicitValueInitExpr *>(S))) return false; } while (false); } break;
case Stmt::InitListExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseInitListExpr, &Derived::TraverseInitListExpr)) { auto ILE = static_cast<InitListExpr *>(S); if (auto Syn = ILE->isSemanticForm() ? ILE->getSyntacticForm() : ILE) do { if (!getDerived().WalkUpFromInitListExpr(Syn)) return false; } while (false); if (auto Sem = ILE->isSemanticForm() ? ILE : ILE->getSemanticForm()) do { if (!getDerived().WalkUpFromInitListExpr(Sem)) return false; } while (false); } break;
case Stmt::IntegerLiteralClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseIntegerLiteral, &Derived::TraverseIntegerLiteral)) { do { if (!getDerived().WalkUpFromIntegerLiteral(static_cast<IntegerLiteral *>(S))) return false; } while (false); } break;
case Stmt::LambdaExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseLambdaExpr, &Derived::TraverseLambdaExpr)) { do { if (!getDerived().WalkUpFromLambdaExpr(static_cast<LambdaExpr *>(S))) return false; } while (false); } break;
case Stmt::MSPropertyRefExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseMSPropertyRefExpr, &Derived::TraverseMSPropertyRefExpr)) { do { if (!getDerived().WalkUpFromMSPropertyRefExpr(static_cast<MSPropertyRefExpr *>(S))) return false; } while (false); } break;
case Stmt::MSPropertySubscriptExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseMSPropertySubscriptExpr, &Derived::TraverseMSPropertySubscriptExpr)) { do { if (!getDerived().WalkUpFromMSPropertySubscriptExpr(static_cast<MSPropertySubscriptExpr *>(S))) return false; } while (false); } break;
case Stmt::MaterializeTemporaryExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseMaterializeTemporaryExpr, &Derived::TraverseMaterializeTemporaryExpr)) { do { if (!getDerived().WalkUpFromMaterializeTemporaryExpr(static_cast<MaterializeTemporaryExpr *>(S))) return false; } while (false); } break;
case Stmt::MatrixSubscriptExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseMatrixSubscriptExpr, &Derived::TraverseMatrixSubscriptExpr)) { do { if (!getDerived().WalkUpFromMatrixSubscriptExpr(static_cast<MatrixSubscriptExpr *>(S))) return false; } while (false); } break;
case Stmt::MemberExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseMemberExpr, &Derived::TraverseMemberExpr)) { do { if (!getDerived().WalkUpFromMemberExpr(static_cast<MemberExpr *>(S))) return false; } while (false); } break;
case Stmt::NoInitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseNoInitExpr, &Derived::TraverseNoInitExpr)) { do { if (!getDerived().WalkUpFromNoInitExpr(static_cast<NoInitExpr *>(S))) return false; } while (false); } break;
case Stmt::OMPArraySectionExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPArraySectionExpr, &Derived::TraverseOMPArraySectionExpr)) { do { if (!getDerived().WalkUpFromOMPArraySectionExpr(static_cast<OMPArraySectionExpr *>(S))) return false; } while (false); } break;
case Stmt::OMPArrayShapingExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPArrayShapingExpr, &Derived::TraverseOMPArrayShapingExpr)) { do { if (!getDerived().WalkUpFromOMPArrayShapingExpr(static_cast<OMPArrayShapingExpr *>(S))) return false; } while (false); } break;
case Stmt::OMPIteratorExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPIteratorExpr, &Derived::TraverseOMPIteratorExpr)) { do { if (!getDerived().WalkUpFromOMPIteratorExpr(static_cast<OMPIteratorExpr *>(S))) return false; } while (false); } break;
case Stmt::ObjCArrayLiteralClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCArrayLiteral, &Derived::TraverseObjCArrayLiteral)) { do { if (!getDerived().WalkUpFromObjCArrayLiteral(static_cast<ObjCArrayLiteral *>(S))) return false; } while (false); } break;
case Stmt::ObjCAvailabilityCheckExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCAvailabilityCheckExpr, &Derived::TraverseObjCAvailabilityCheckExpr)) { do { if (!getDerived().WalkUpFromObjCAvailabilityCheckExpr(static_cast<ObjCAvailabilityCheckExpr *>(S))) return false; } while (false); } break;
case Stmt::ObjCBoolLiteralExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCBoolLiteralExpr, &Derived::TraverseObjCBoolLiteralExpr)) { do { if (!getDerived().WalkUpFromObjCBoolLiteralExpr(static_cast<ObjCBoolLiteralExpr *>(S))) return false; } while (false); } break;
case Stmt::ObjCBoxedExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCBoxedExpr, &Derived::TraverseObjCBoxedExpr)) { do { if (!getDerived().WalkUpFromObjCBoxedExpr(static_cast<ObjCBoxedExpr *>(S))) return false; } while (false); } break;
case Stmt::ObjCDictionaryLiteralClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCDictionaryLiteral, &Derived::TraverseObjCDictionaryLiteral)) { do { if (!getDerived().WalkUpFromObjCDictionaryLiteral(static_cast<ObjCDictionaryLiteral *>(S))) return false; } while (false); } break;
case Stmt::ObjCEncodeExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCEncodeExpr, &Derived::TraverseObjCEncodeExpr)) { do { if (!getDerived().WalkUpFromObjCEncodeExpr(static_cast<ObjCEncodeExpr *>(S))) return false; } while (false); } break;
case Stmt::ObjCIndirectCopyRestoreExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCIndirectCopyRestoreExpr, &Derived::TraverseObjCIndirectCopyRestoreExpr)) { do { if (!getDerived().WalkUpFromObjCIndirectCopyRestoreExpr(static_cast<ObjCIndirectCopyRestoreExpr *>(S))) return false; } while (false); } break;
case Stmt::ObjCIsaExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCIsaExpr, &Derived::TraverseObjCIsaExpr)) { do { if (!getDerived().WalkUpFromObjCIsaExpr(static_cast<ObjCIsaExpr *>(S))) return false; } while (false); } break;
case Stmt::ObjCIvarRefExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCIvarRefExpr, &Derived::TraverseObjCIvarRefExpr)) { do { if (!getDerived().WalkUpFromObjCIvarRefExpr(static_cast<ObjCIvarRefExpr *>(S))) return false; } while (false); } break;
case Stmt::ObjCMessageExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCMessageExpr, &Derived::TraverseObjCMessageExpr)) { do { if (!getDerived().WalkUpFromObjCMessageExpr(static_cast<ObjCMessageExpr *>(S))) return false; } while (false); } break;
case Stmt::ObjCPropertyRefExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCPropertyRefExpr, &Derived::TraverseObjCPropertyRefExpr)) { do { if (!getDerived().WalkUpFromObjCPropertyRefExpr(static_cast<ObjCPropertyRefExpr *>(S))) return false; } while (false); } break;
case Stmt::ObjCProtocolExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCProtocolExpr, &Derived::TraverseObjCProtocolExpr)) { do { if (!getDerived().WalkUpFromObjCProtocolExpr(static_cast<ObjCProtocolExpr *>(S))) return false; } while (false); } break;
case Stmt::ObjCSelectorExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCSelectorExpr, &Derived::TraverseObjCSelectorExpr)) { do { if (!getDerived().WalkUpFromObjCSelectorExpr(static_cast<ObjCSelectorExpr *>(S))) return false; } while (false); } break;
case Stmt::ObjCStringLiteralClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCStringLiteral, &Derived::TraverseObjCStringLiteral)) { do { if (!getDerived().WalkUpFromObjCStringLiteral(static_cast<ObjCStringLiteral *>(S))) return false; } while (false); } break;
case Stmt::ObjCSubscriptRefExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCSubscriptRefExpr, &Derived::TraverseObjCSubscriptRefExpr)) { do { if (!getDerived().WalkUpFromObjCSubscriptRefExpr(static_cast<ObjCSubscriptRefExpr *>(S))) return false; } while (false); } break;
case Stmt::OffsetOfExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOffsetOfExpr, &Derived::TraverseOffsetOfExpr)) { do { if (!getDerived().WalkUpFromOffsetOfExpr(static_cast<OffsetOfExpr *>(S))) return false; } while (false); } break;
case Stmt::OpaqueValueExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOpaqueValueExpr, &Derived::TraverseOpaqueValueExpr)) { do { if (!getDerived().WalkUpFromOpaqueValueExpr(static_cast<OpaqueValueExpr *>(S))) return false; } while (false); } break;
case Stmt::UnresolvedLookupExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseUnresolvedLookupExpr, &Derived::TraverseUnresolvedLookupExpr)) { do { if (!getDerived().WalkUpFromUnresolvedLookupExpr(static_cast<UnresolvedLookupExpr *>(S))) return false; } while (false); } break;
case Stmt::UnresolvedMemberExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseUnresolvedMemberExpr, &Derived::TraverseUnresolvedMemberExpr)) { do { if (!getDerived().WalkUpFromUnresolvedMemberExpr(static_cast<UnresolvedMemberExpr *>(S))) return false; } while (false); } break;
case Stmt::PackExpansionExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraversePackExpansionExpr, &Derived::TraversePackExpansionExpr)) { do { if (!getDerived().WalkUpFromPackExpansionExpr(static_cast<PackExpansionExpr *>(S))) return false; } while (false); } break;
case Stmt::ParenExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseParenExpr, &Derived::TraverseParenExpr)) { do { if (!getDerived().WalkUpFromParenExpr(static_cast<ParenExpr *>(S))) return false; } while (false); } break;
case Stmt::ParenListExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseParenListExpr, &Derived::TraverseParenListExpr)) { do { if (!getDerived().WalkUpFromParenListExpr(static_cast<ParenListExpr *>(S))) return false; } while (false); } break;
case Stmt::PredefinedExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraversePredefinedExpr, &Derived::TraversePredefinedExpr)) { do { if (!getDerived().WalkUpFromPredefinedExpr(static_cast<PredefinedExpr *>(S))) return false; } while (false); } break;
case Stmt::PseudoObjectExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraversePseudoObjectExpr, &Derived::TraversePseudoObjectExpr)) { do { if (!getDerived().WalkUpFromPseudoObjectExpr(static_cast<PseudoObjectExpr *>(S))) return false; } while (false); } break;
case Stmt::RecoveryExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseRecoveryExpr, &Derived::TraverseRecoveryExpr)) { do { if (!getDerived().WalkUpFromRecoveryExpr(static_cast<RecoveryExpr *>(S))) return false; } while (false); } break;
case Stmt::RequiresExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseRequiresExpr, &Derived::TraverseRequiresExpr)) { do { if (!getDerived().WalkUpFromRequiresExpr(static_cast<RequiresExpr *>(S))) return false; } while (false); } break;
case Stmt::SYCLUniqueStableNameExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseSYCLUniqueStableNameExpr, &Derived::TraverseSYCLUniqueStableNameExpr)) { do { if (!getDerived().WalkUpFromSYCLUniqueStableNameExpr(static_cast<SYCLUniqueStableNameExpr *>(S))) return false; } while (false); } break;
case Stmt::ShuffleVectorExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseShuffleVectorExpr, &Derived::TraverseShuffleVectorExpr)) { do { if (!getDerived().WalkUpFromShuffleVectorExpr(static_cast<ShuffleVectorExpr *>(S))) return false; } while (false); } break;
case Stmt::SizeOfPackExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseSizeOfPackExpr, &Derived::TraverseSizeOfPackExpr)) { do { if (!getDerived().WalkUpFromSizeOfPackExpr(static_cast<SizeOfPackExpr *>(S))) return false; } while (false); } break;
case Stmt::SourceLocExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseSourceLocExpr, &Derived::TraverseSourceLocExpr)) { do { if (!getDerived().WalkUpFromSourceLocExpr(static_cast<SourceLocExpr *>(S))) return false; } while (false); } break;
case Stmt::StmtExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseStmtExpr, &Derived::TraverseStmtExpr)) { do { if (!getDerived().WalkUpFromStmtExpr(static_cast<StmtExpr *>(S))) return false; } while (false); } break;
case Stmt::StringLiteralClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseStringLiteral, &Derived::TraverseStringLiteral)) { do { if (!getDerived().WalkUpFromStringLiteral(static_cast<StringLiteral *>(S))) return false; } while (false); } break;
case Stmt::SubstNonTypeTemplateParmExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseSubstNonTypeTemplateParmExpr, &Derived::TraverseSubstNonTypeTemplateParmExpr)) { do { if (!getDerived().WalkUpFromSubstNonTypeTemplateParmExpr(static_cast<SubstNonTypeTemplateParmExpr *>(S))) return false; } while (false); } break;
case Stmt::SubstNonTypeTemplateParmPackExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseSubstNonTypeTemplateParmPackExpr, &Derived::TraverseSubstNonTypeTemplateParmPackExpr)) { do { if (!getDerived().WalkUpFromSubstNonTypeTemplateParmPackExpr(static_cast<SubstNonTypeTemplateParmPackExpr *>(S))) return false; } while (false); } break;
case Stmt::TypeTraitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseTypeTraitExpr, &Derived::TraverseTypeTraitExpr)) { do { if (!getDerived().WalkUpFromTypeTraitExpr(static_cast<TypeTraitExpr *>(S))) return false; } while (false); } break;
case Stmt::TypoExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseTypoExpr, &Derived::TraverseTypoExpr)) { do { if (!getDerived().WalkUpFromTypoExpr(static_cast<TypoExpr *>(S))) return false; } while (false); } break;
case Stmt::UnaryExprOrTypeTraitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseUnaryExprOrTypeTraitExpr, &Derived::TraverseUnaryExprOrTypeTraitExpr)) { do { if (!getDerived().WalkUpFromUnaryExprOrTypeTraitExpr(static_cast<UnaryExprOrTypeTraitExpr *>(S))) return false; } while (false); } break;
case Stmt::UnaryOperatorClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseUnaryOperator, &Derived::TraverseUnaryOperator)) { do { if (!getDerived().WalkUpFromUnaryOperator(static_cast<UnaryOperator *>(S))) return false; } while (false); } break;
case Stmt::VAArgExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseVAArgExpr, &Derived::TraverseVAArgExpr)) { do { if (!getDerived().WalkUpFromVAArgExpr(static_cast<VAArgExpr *>(S))) return false; } while (false); } break;
case Stmt::LabelStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseLabelStmt, &Derived::TraverseLabelStmt)) { do { if (!getDerived().WalkUpFromLabelStmt(static_cast<LabelStmt *>(S))) return false; } while (false); } break;
case Stmt::WhileStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseWhileStmt, &Derived::TraverseWhileStmt)) { do { if (!getDerived().WalkUpFromWhileStmt(static_cast<WhileStmt *>(S))) return false; } while (false); } break;
 }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseStmt(Stmt *S,
                                                DataRecursionQueue *Queue) {
  if (!S)
    return true;
  if (Queue) {
    Queue->push_back({S, false});
    return true;
  }
  SmallVector<llvm::PointerIntPair<Stmt *, 1, bool>, 8> LocalQueue;
  LocalQueue.push_back({S, false});
  while (!LocalQueue.empty()) {
    auto &CurrSAndVisited = LocalQueue.back();
    Stmt *CurrS = CurrSAndVisited.getPointer();
    bool Visited = CurrSAndVisited.getInt();
    if (Visited) {
      LocalQueue.pop_back();
      do { if (!getDerived().dataTraverseStmtPost(CurrS)) return false; } while (false);
      if (getDerived().shouldTraversePostOrder()) {
        do { if (!getDerived().PostVisitStmt(CurrS)) return false; } while (false);
      }
      continue;
    }
    if (getDerived().dataTraverseStmtPre(CurrS)) {
      CurrSAndVisited.setInt(true);
      size_t N = LocalQueue.size();
      do { if (!getDerived().dataTraverseNode(CurrS, &LocalQueue)) return false; } while (false);
      std::reverse(LocalQueue.begin() + N, LocalQueue.end());
    } else {
      LocalQueue.pop_back();
    }
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseType(QualType T) {
  if (T.isNull())
    return true;
  switch (T->getTypeClass()) {
case Type::Adjusted: return getDerived().TraverseAdjustedType( static_cast<AdjustedType *>(const_cast<Type *>(T.getTypePtr())));
case Type::Decayed: return getDerived().TraverseDecayedType( static_cast<DecayedType *>(const_cast<Type *>(T.getTypePtr())));
case Type::ConstantArray: return getDerived().TraverseConstantArrayType( static_cast<ConstantArrayType *>(const_cast<Type *>(T.getTypePtr())));
case Type::DependentSizedArray: return getDerived().TraverseDependentSizedArrayType( static_cast<DependentSizedArrayType *>(const_cast<Type *>(T.getTypePtr())));
case Type::IncompleteArray: return getDerived().TraverseIncompleteArrayType( static_cast<IncompleteArrayType *>(const_cast<Type *>(T.getTypePtr())));
case Type::VariableArray: return getDerived().TraverseVariableArrayType( static_cast<VariableArrayType *>(const_cast<Type *>(T.getTypePtr())));
case Type::Atomic: return getDerived().TraverseAtomicType( static_cast<AtomicType *>(const_cast<Type *>(T.getTypePtr())));
case Type::Attributed: return getDerived().TraverseAttributedType( static_cast<AttributedType *>(const_cast<Type *>(T.getTypePtr())));
case Type::BlockPointer: return getDerived().TraverseBlockPointerType( static_cast<BlockPointerType *>(const_cast<Type *>(T.getTypePtr())));
case Type::Builtin: return getDerived().TraverseBuiltinType( static_cast<BuiltinType *>(const_cast<Type *>(T.getTypePtr())));
case Type::Complex: return getDerived().TraverseComplexType( static_cast<ComplexType *>(const_cast<Type *>(T.getTypePtr())));
case Type::Decltype: return getDerived().TraverseDecltypeType( static_cast<DecltypeType *>(const_cast<Type *>(T.getTypePtr())));
case Type::Auto: return getDerived().TraverseAutoType( static_cast<AutoType *>(const_cast<Type *>(T.getTypePtr())));
case Type::DeducedTemplateSpecialization: return getDerived().TraverseDeducedTemplateSpecializationType( static_cast<DeducedTemplateSpecializationType *>(const_cast<Type *>(T.getTypePtr())));
case Type::DependentAddressSpace: return getDerived().TraverseDependentAddressSpaceType( static_cast<DependentAddressSpaceType *>(const_cast<Type *>(T.getTypePtr())));
case Type::DependentExtInt: return getDerived().TraverseDependentExtIntType( static_cast<DependentExtIntType *>(const_cast<Type *>(T.getTypePtr())));
case Type::DependentName: return getDerived().TraverseDependentNameType( static_cast<DependentNameType *>(const_cast<Type *>(T.getTypePtr())));
case Type::DependentSizedExtVector: return getDerived().TraverseDependentSizedExtVectorType( static_cast<DependentSizedExtVectorType *>(const_cast<Type *>(T.getTypePtr())));
case Type::DependentTemplateSpecialization: return getDerived().TraverseDependentTemplateSpecializationType( static_cast<DependentTemplateSpecializationType *>(const_cast<Type *>(T.getTypePtr())));
case Type::DependentVector: return getDerived().TraverseDependentVectorType( static_cast<DependentVectorType *>(const_cast<Type *>(T.getTypePtr())));
case Type::Elaborated: return getDerived().TraverseElaboratedType( static_cast<ElaboratedType *>(const_cast<Type *>(T.getTypePtr())));
case Type::ExtInt: return getDerived().TraverseExtIntType( static_cast<ExtIntType *>(const_cast<Type *>(T.getTypePtr())));
case Type::FunctionNoProto: return getDerived().TraverseFunctionNoProtoType( static_cast<FunctionNoProtoType *>(const_cast<Type *>(T.getTypePtr())));
case Type::FunctionProto: return getDerived().TraverseFunctionProtoType( static_cast<FunctionProtoType *>(const_cast<Type *>(T.getTypePtr())));
case Type::InjectedClassName: return getDerived().TraverseInjectedClassNameType( static_cast<InjectedClassNameType *>(const_cast<Type *>(T.getTypePtr())));
case Type::MacroQualified: return getDerived().TraverseMacroQualifiedType( static_cast<MacroQualifiedType *>(const_cast<Type *>(T.getTypePtr())));
case Type::ConstantMatrix: return getDerived().TraverseConstantMatrixType( static_cast<ConstantMatrixType *>(const_cast<Type *>(T.getTypePtr())));
case Type::DependentSizedMatrix: return getDerived().TraverseDependentSizedMatrixType( static_cast<DependentSizedMatrixType *>(const_cast<Type *>(T.getTypePtr())));
case Type::MemberPointer: return getDerived().TraverseMemberPointerType( static_cast<MemberPointerType *>(const_cast<Type *>(T.getTypePtr())));
case Type::ObjCObjectPointer: return getDerived().TraverseObjCObjectPointerType( static_cast<ObjCObjectPointerType *>(const_cast<Type *>(T.getTypePtr())));
case Type::ObjCObject: return getDerived().TraverseObjCObjectType( static_cast<ObjCObjectType *>(const_cast<Type *>(T.getTypePtr())));
case Type::ObjCInterface: return getDerived().TraverseObjCInterfaceType( static_cast<ObjCInterfaceType *>(const_cast<Type *>(T.getTypePtr())));
case Type::ObjCTypeParam: return getDerived().TraverseObjCTypeParamType( static_cast<ObjCTypeParamType *>(const_cast<Type *>(T.getTypePtr())));
case Type::PackExpansion: return getDerived().TraversePackExpansionType( static_cast<PackExpansionType *>(const_cast<Type *>(T.getTypePtr())));
case Type::Paren: return getDerived().TraverseParenType( static_cast<ParenType *>(const_cast<Type *>(T.getTypePtr())));
case Type::Pipe: return getDerived().TraversePipeType( static_cast<PipeType *>(const_cast<Type *>(T.getTypePtr())));
case Type::Pointer: return getDerived().TraversePointerType( static_cast<PointerType *>(const_cast<Type *>(T.getTypePtr())));
case Type::LValueReference: return getDerived().TraverseLValueReferenceType( static_cast<LValueReferenceType *>(const_cast<Type *>(T.getTypePtr())));
case Type::RValueReference: return getDerived().TraverseRValueReferenceType( static_cast<RValueReferenceType *>(const_cast<Type *>(T.getTypePtr())));
case Type::SubstTemplateTypeParmPack: return getDerived().TraverseSubstTemplateTypeParmPackType( static_cast<SubstTemplateTypeParmPackType *>(const_cast<Type *>(T.getTypePtr())));
case Type::SubstTemplateTypeParm: return getDerived().TraverseSubstTemplateTypeParmType( static_cast<SubstTemplateTypeParmType *>(const_cast<Type *>(T.getTypePtr())));
case Type::Enum: return getDerived().TraverseEnumType( static_cast<EnumType *>(const_cast<Type *>(T.getTypePtr())));
case Type::Record: return getDerived().TraverseRecordType( static_cast<RecordType *>(const_cast<Type *>(T.getTypePtr())));
case Type::TemplateSpecialization: return getDerived().TraverseTemplateSpecializationType( static_cast<TemplateSpecializationType *>(const_cast<Type *>(T.getTypePtr())));
case Type::TemplateTypeParm: return getDerived().TraverseTemplateTypeParmType( static_cast<TemplateTypeParmType *>(const_cast<Type *>(T.getTypePtr())));
case Type::TypeOfExpr: return getDerived().TraverseTypeOfExprType( static_cast<TypeOfExprType *>(const_cast<Type *>(T.getTypePtr())));
case Type::TypeOf: return getDerived().TraverseTypeOfType( static_cast<TypeOfType *>(const_cast<Type *>(T.getTypePtr())));
case Type::Typedef: return getDerived().TraverseTypedefType( static_cast<TypedefType *>(const_cast<Type *>(T.getTypePtr())));
case Type::UnaryTransform: return getDerived().TraverseUnaryTransformType( static_cast<UnaryTransformType *>(const_cast<Type *>(T.getTypePtr())));
case Type::UnresolvedUsing: return getDerived().TraverseUnresolvedUsingType( static_cast<UnresolvedUsingType *>(const_cast<Type *>(T.getTypePtr())));
case Type::Vector: return getDerived().TraverseVectorType( static_cast<VectorType *>(const_cast<Type *>(T.getTypePtr())));
case Type::ExtVector: return getDerived().TraverseExtVectorType( static_cast<ExtVectorType *>(const_cast<Type *>(T.getTypePtr())));
 }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTypeLoc(TypeLoc TL) {
  if (TL.isNull())
    return true;
  switch (TL.getTypeLocClass()) {
case TypeLoc::Qualified: return getDerived().TraverseQualifiedTypeLoc(TL.castAs<QualifiedTypeLoc>());
case TypeLoc::Adjusted: return getDerived().TraverseAdjustedTypeLoc(TL.castAs<AdjustedTypeLoc>());
case TypeLoc::Decayed: return getDerived().TraverseDecayedTypeLoc(TL.castAs<DecayedTypeLoc>());
case TypeLoc::ConstantArray: return getDerived().TraverseConstantArrayTypeLoc(TL.castAs<ConstantArrayTypeLoc>());
case TypeLoc::DependentSizedArray: return getDerived().TraverseDependentSizedArrayTypeLoc(TL.castAs<DependentSizedArrayTypeLoc>());
case TypeLoc::IncompleteArray: return getDerived().TraverseIncompleteArrayTypeLoc(TL.castAs<IncompleteArrayTypeLoc>());
case TypeLoc::VariableArray: return getDerived().TraverseVariableArrayTypeLoc(TL.castAs<VariableArrayTypeLoc>());
case TypeLoc::Atomic: return getDerived().TraverseAtomicTypeLoc(TL.castAs<AtomicTypeLoc>());
case TypeLoc::Attributed: return getDerived().TraverseAttributedTypeLoc(TL.castAs<AttributedTypeLoc>());
case TypeLoc::BlockPointer: return getDerived().TraverseBlockPointerTypeLoc(TL.castAs<BlockPointerTypeLoc>());
case TypeLoc::Builtin: return getDerived().TraverseBuiltinTypeLoc(TL.castAs<BuiltinTypeLoc>());
case TypeLoc::Complex: return getDerived().TraverseComplexTypeLoc(TL.castAs<ComplexTypeLoc>());
case TypeLoc::Decltype: return getDerived().TraverseDecltypeTypeLoc(TL.castAs<DecltypeTypeLoc>());
case TypeLoc::Auto: return getDerived().TraverseAutoTypeLoc(TL.castAs<AutoTypeLoc>());
case TypeLoc::DeducedTemplateSpecialization: return getDerived().TraverseDeducedTemplateSpecializationTypeLoc(TL.castAs<DeducedTemplateSpecializationTypeLoc>());
case TypeLoc::DependentAddressSpace: return getDerived().TraverseDependentAddressSpaceTypeLoc(TL.castAs<DependentAddressSpaceTypeLoc>());
case TypeLoc::DependentExtInt: return getDerived().TraverseDependentExtIntTypeLoc(TL.castAs<DependentExtIntTypeLoc>());
case TypeLoc::DependentName: return getDerived().TraverseDependentNameTypeLoc(TL.castAs<DependentNameTypeLoc>());
case TypeLoc::DependentSizedExtVector: return getDerived().TraverseDependentSizedExtVectorTypeLoc(TL.castAs<DependentSizedExtVectorTypeLoc>());
case TypeLoc::DependentTemplateSpecialization: return getDerived().TraverseDependentTemplateSpecializationTypeLoc(TL.castAs<DependentTemplateSpecializationTypeLoc>());
case TypeLoc::DependentVector: return getDerived().TraverseDependentVectorTypeLoc(TL.castAs<DependentVectorTypeLoc>());
case TypeLoc::Elaborated: return getDerived().TraverseElaboratedTypeLoc(TL.castAs<ElaboratedTypeLoc>());
case TypeLoc::ExtInt: return getDerived().TraverseExtIntTypeLoc(TL.castAs<ExtIntTypeLoc>());
case TypeLoc::FunctionNoProto: return getDerived().TraverseFunctionNoProtoTypeLoc(TL.castAs<FunctionNoProtoTypeLoc>());
case TypeLoc::FunctionProto: return getDerived().TraverseFunctionProtoTypeLoc(TL.castAs<FunctionProtoTypeLoc>());
case TypeLoc::InjectedClassName: return getDerived().TraverseInjectedClassNameTypeLoc(TL.castAs<InjectedClassNameTypeLoc>());
case TypeLoc::MacroQualified: return getDerived().TraverseMacroQualifiedTypeLoc(TL.castAs<MacroQualifiedTypeLoc>());
case TypeLoc::ConstantMatrix: return getDerived().TraverseConstantMatrixTypeLoc(TL.castAs<ConstantMatrixTypeLoc>());
case TypeLoc::DependentSizedMatrix: return getDerived().TraverseDependentSizedMatrixTypeLoc(TL.castAs<DependentSizedMatrixTypeLoc>());
case TypeLoc::MemberPointer: return getDerived().TraverseMemberPointerTypeLoc(TL.castAs<MemberPointerTypeLoc>());
case TypeLoc::ObjCObjectPointer: return getDerived().TraverseObjCObjectPointerTypeLoc(TL.castAs<ObjCObjectPointerTypeLoc>());
case TypeLoc::ObjCObject: return getDerived().TraverseObjCObjectTypeLoc(TL.castAs<ObjCObjectTypeLoc>());
case TypeLoc::ObjCInterface: return getDerived().TraverseObjCInterfaceTypeLoc(TL.castAs<ObjCInterfaceTypeLoc>());
case TypeLoc::ObjCTypeParam: return getDerived().TraverseObjCTypeParamTypeLoc(TL.castAs<ObjCTypeParamTypeLoc>());
case TypeLoc::PackExpansion: return getDerived().TraversePackExpansionTypeLoc(TL.castAs<PackExpansionTypeLoc>());
case TypeLoc::Paren: return getDerived().TraverseParenTypeLoc(TL.castAs<ParenTypeLoc>());
case TypeLoc::Pipe: return getDerived().TraversePipeTypeLoc(TL.castAs<PipeTypeLoc>());
case TypeLoc::Pointer: return getDerived().TraversePointerTypeLoc(TL.castAs<PointerTypeLoc>());
case TypeLoc::LValueReference: return getDerived().TraverseLValueReferenceTypeLoc(TL.castAs<LValueReferenceTypeLoc>());
case TypeLoc::RValueReference: return getDerived().TraverseRValueReferenceTypeLoc(TL.castAs<RValueReferenceTypeLoc>());
case TypeLoc::SubstTemplateTypeParmPack: return getDerived().TraverseSubstTemplateTypeParmPackTypeLoc(TL.castAs<SubstTemplateTypeParmPackTypeLoc>());
case TypeLoc::SubstTemplateTypeParm: return getDerived().TraverseSubstTemplateTypeParmTypeLoc(TL.castAs<SubstTemplateTypeParmTypeLoc>());
case TypeLoc::Enum: return getDerived().TraverseEnumTypeLoc(TL.castAs<EnumTypeLoc>());
case TypeLoc::Record: return getDerived().TraverseRecordTypeLoc(TL.castAs<RecordTypeLoc>());
case TypeLoc::TemplateSpecialization: return getDerived().TraverseTemplateSpecializationTypeLoc(TL.castAs<TemplateSpecializationTypeLoc>());
case TypeLoc::TemplateTypeParm: return getDerived().TraverseTemplateTypeParmTypeLoc(TL.castAs<TemplateTypeParmTypeLoc>());
case TypeLoc::TypeOfExpr: return getDerived().TraverseTypeOfExprTypeLoc(TL.castAs<TypeOfExprTypeLoc>());
case TypeLoc::TypeOf: return getDerived().TraverseTypeOfTypeLoc(TL.castAs<TypeOfTypeLoc>());
case TypeLoc::Typedef: return getDerived().TraverseTypedefTypeLoc(TL.castAs<TypedefTypeLoc>());
case TypeLoc::UnaryTransform: return getDerived().TraverseUnaryTransformTypeLoc(TL.castAs<UnaryTransformTypeLoc>());
case TypeLoc::UnresolvedUsing: return getDerived().TraverseUnresolvedUsingTypeLoc(TL.castAs<UnresolvedUsingTypeLoc>());
case TypeLoc::Vector: return getDerived().TraverseVectorTypeLoc(TL.castAs<VectorTypeLoc>());
case TypeLoc::ExtVector: return getDerived().TraverseExtVectorTypeLoc(TL.castAs<ExtVectorTypeLoc>());
 }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAArch64VectorPcsAttr(AArch64VectorPcsAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAArch64VectorPcsAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAMDGPUFlatWorkGroupSizeAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getMin()))
    return false;
  if (!getDerived().TraverseStmt(A->getMax()))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAMDGPUNumSGPRAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAMDGPUNumVGPRAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAMDGPUWavesPerEUAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getMin()))
    return false;
  if (!getDerived().TraverseStmt(A->getMax()))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseARMInterruptAttr(ARMInterruptAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitARMInterruptAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAVRInterruptAttr(AVRInterruptAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAVRInterruptAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAVRSignalAttr(AVRSignalAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAVRSignalAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAbiTagAttr(AbiTagAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAbiTagAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAcquireCapabilityAttr(AcquireCapabilityAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAcquireCapabilityAttr(A))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAcquireHandleAttr(AcquireHandleAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAcquireHandleAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAcquiredAfterAttr(AcquiredAfterAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAcquiredAfterAttr(A))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAcquiredBeforeAttr(AcquiredBeforeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAcquiredBeforeAttr(A))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAddressSpaceAttr(AddressSpaceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAddressSpaceAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAliasAttr(AliasAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAliasAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAlignMac68kAttr(AlignMac68kAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAlignMac68kAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAlignNaturalAttr(AlignNaturalAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAlignNaturalAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAlignValueAttr(AlignValueAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAlignValueAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getAlignment()))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAlignedAttr(AlignedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAlignedAttr(A))
    return false;
  if (A->isAlignmentExpr()) {
    if (!getDerived().TraverseStmt(A->getAlignmentExpr()))
      return false;
  } else if (auto *TSI = A->getAlignmentType()) {
    if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
      return false;
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAllocAlignAttr(AllocAlignAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAllocAlignAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAllocSizeAttr(AllocSizeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAllocSizeAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAlwaysDestroyAttr(AlwaysDestroyAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAlwaysDestroyAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAlwaysInlineAttr(AlwaysInlineAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAlwaysInlineAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAnalyzerNoReturnAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAnnotateAttr(AnnotateAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAnnotateAttr(A))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAnyX86InterruptAttr(AnyX86InterruptAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAnyX86InterruptAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAnyX86NoCallerSavedRegistersAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAnyX86NoCfCheckAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitArcWeakrefUnavailableAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitArgumentWithTypeTagAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseArmBuiltinAliasAttr(ArmBuiltinAliasAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitArmBuiltinAliasAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitArmMveStrictPolymorphismAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseArtificialAttr(ArtificialAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitArtificialAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAsmLabelAttr(AsmLabelAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAsmLabelAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAssertCapabilityAttr(AssertCapabilityAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAssertCapabilityAttr(A))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAssertExclusiveLockAttr(AssertExclusiveLockAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAssertExclusiveLockAttr(A))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAssertSharedLockAttr(AssertSharedLockAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAssertSharedLockAttr(A))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAssumeAlignedAttr(AssumeAlignedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAssumeAlignedAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getAlignment()))
    return false;
  if (!getDerived().TraverseStmt(A->getOffset()))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAssumptionAttr(AssumptionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAssumptionAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAvailabilityAttr(AvailabilityAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAvailabilityAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitBPFPreserveAccessIndexAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseBlocksAttr(BlocksAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitBlocksAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseBuiltinAttr(BuiltinAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitBuiltinAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseBuiltinAliasAttr(BuiltinAliasAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitBuiltinAliasAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseC11NoReturnAttr(C11NoReturnAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitC11NoReturnAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCDeclAttr(CDeclAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCDeclAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCFAuditedTransferAttr(CFAuditedTransferAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCFAuditedTransferAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCFConsumedAttr(CFConsumedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCFConsumedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCFGuardAttr(CFGuardAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCFGuardAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCFICanonicalJumpTableAttr(CFICanonicalJumpTableAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCFICanonicalJumpTableAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCFReturnsNotRetainedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCFReturnsRetainedAttr(CFReturnsRetainedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCFReturnsRetainedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCFUnknownTransferAttr(CFUnknownTransferAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCFUnknownTransferAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCPUDispatchAttr(CPUDispatchAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCPUDispatchAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCPUSpecificAttr(CPUSpecificAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCPUSpecificAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCUDAConstantAttr(CUDAConstantAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCUDAConstantAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCUDADeviceAttr(CUDADeviceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCUDADeviceAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCUDADeviceBuiltinSurfaceTypeAttr(CUDADeviceBuiltinSurfaceTypeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCUDADeviceBuiltinSurfaceTypeAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCUDADeviceBuiltinTextureTypeAttr(CUDADeviceBuiltinTextureTypeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCUDADeviceBuiltinTextureTypeAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCUDAGlobalAttr(CUDAGlobalAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCUDAGlobalAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCUDAHostAttr(CUDAHostAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCUDAHostAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCUDAInvalidTargetAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCUDALaunchBoundsAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getMaxThreads()))
    return false;
  if (!getDerived().TraverseStmt(A->getMinBlocks()))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCUDASharedAttr(CUDASharedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCUDASharedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCXX11NoReturnAttr(CXX11NoReturnAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCXX11NoReturnAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCallableWhenAttr(CallableWhenAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCallableWhenAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCallbackAttr(CallbackAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCallbackAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCalledOnceAttr(CalledOnceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCalledOnceAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCapabilityAttr(CapabilityAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCapabilityAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCapturedRecordAttr(CapturedRecordAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCapturedRecordAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCarriesDependencyAttr(CarriesDependencyAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCarriesDependencyAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCleanupAttr(CleanupAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCleanupAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCmseNSCallAttr(CmseNSCallAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCmseNSCallAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCmseNSEntryAttr(CmseNSEntryAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCmseNSEntryAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCodeSegAttr(CodeSegAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCodeSegAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseColdAttr(ColdAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitColdAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCommonAttr(CommonAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCommonAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseConstAttr(ConstAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitConstAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseConstInitAttr(ConstInitAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitConstInitAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseConstructorAttr(ConstructorAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitConstructorAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseConsumableAttr(ConsumableAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitConsumableAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseConsumableAutoCastAttr(ConsumableAutoCastAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitConsumableAutoCastAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitConsumableSetOnReadAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseConvergentAttr(ConvergentAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitConvergentAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseDLLExportAttr(DLLExportAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitDLLExportAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseDLLExportStaticLocalAttr(DLLExportStaticLocalAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitDLLExportStaticLocalAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseDLLImportAttr(DLLImportAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitDLLImportAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseDLLImportStaticLocalAttr(DLLImportStaticLocalAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitDLLImportStaticLocalAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseDeprecatedAttr(DeprecatedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitDeprecatedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseDestructorAttr(DestructorAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitDestructorAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseDiagnoseIfAttr(DiagnoseIfAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitDiagnoseIfAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getCond()))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseDisableTailCallsAttr(DisableTailCallsAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitDisableTailCallsAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseEmptyBasesAttr(EmptyBasesAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitEmptyBasesAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseEnableIfAttr(EnableIfAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitEnableIfAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getCond()))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseEnforceTCBAttr(EnforceTCBAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitEnforceTCBAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseEnforceTCBLeafAttr(EnforceTCBLeafAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitEnforceTCBLeafAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseEnumExtensibilityAttr(EnumExtensibilityAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitEnumExtensibilityAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseExcludeFromExplicitInstantiationAttr(ExcludeFromExplicitInstantiationAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitExcludeFromExplicitInstantiationAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitExclusiveTrylockFunctionAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getSuccessValue()))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitExternalSourceSymbolAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseFallThroughAttr(FallThroughAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitFallThroughAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseFastCallAttr(FastCallAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitFastCallAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseFinalAttr(FinalAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitFinalAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseFlagEnumAttr(FlagEnumAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitFlagEnumAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseFlattenAttr(FlattenAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitFlattenAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseFormatAttr(FormatAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitFormatAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseFormatArgAttr(FormatArgAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitFormatArgAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseGNUInlineAttr(GNUInlineAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitGNUInlineAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseGuardedByAttr(GuardedByAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitGuardedByAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getArg()))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseGuardedVarAttr(GuardedVarAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitGuardedVarAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseHIPManagedAttr(HIPManagedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitHIPManagedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseHotAttr(HotAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitHotAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseIBActionAttr(IBActionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitIBActionAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseIBOutletAttr(IBOutletAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitIBOutletAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseIBOutletCollectionAttr(IBOutletCollectionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitIBOutletCollectionAttr(A))
    return false;
  if (auto *TSI = A->getInterfaceLoc())
    if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
      return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseIFuncAttr(IFuncAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitIFuncAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseInitPriorityAttr(InitPriorityAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitInitPriorityAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseInitSegAttr(InitSegAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitInitSegAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseIntelOclBiccAttr(IntelOclBiccAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitIntelOclBiccAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseInternalLinkageAttr(InternalLinkageAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitInternalLinkageAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitLTOVisibilityPublicAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseLayoutVersionAttr(LayoutVersionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitLayoutVersionAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseLeafAttr(LeafAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitLeafAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseLifetimeBoundAttr(LifetimeBoundAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitLifetimeBoundAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseLikelyAttr(LikelyAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitLikelyAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseLoaderUninitializedAttr(LoaderUninitializedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitLoaderUninitializedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseLockReturnedAttr(LockReturnedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitLockReturnedAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getArg()))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseLocksExcludedAttr(LocksExcludedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitLocksExcludedAttr(A))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseLoopHintAttr(LoopHintAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitLoopHintAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getValue()))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseM68kInterruptAttr(M68kInterruptAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitM68kInterruptAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseMIGServerRoutineAttr(MIGServerRoutineAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMIGServerRoutineAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseMSABIAttr(MSABIAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMSABIAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseMSAllocatorAttr(MSAllocatorAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMSAllocatorAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseMSInheritanceAttr(MSInheritanceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMSInheritanceAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseMSNoVTableAttr(MSNoVTableAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMSNoVTableAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseMSP430InterruptAttr(MSP430InterruptAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMSP430InterruptAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseMSStructAttr(MSStructAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMSStructAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseMSVtorDispAttr(MSVtorDispAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMSVtorDispAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMaxFieldAlignmentAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseMayAliasAttr(MayAliasAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMayAliasAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseMicroMipsAttr(MicroMipsAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMicroMipsAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseMinSizeAttr(MinSizeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMinSizeAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseMinVectorWidthAttr(MinVectorWidthAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMinVectorWidthAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseMips16Attr(Mips16Attr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMips16Attr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseMipsInterruptAttr(MipsInterruptAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMipsInterruptAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseMipsLongCallAttr(MipsLongCallAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMipsLongCallAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseMipsShortCallAttr(MipsShortCallAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMipsShortCallAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseModeAttr(ModeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitModeAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseMustTailAttr(MustTailAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMustTailAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNSConsumedAttr(NSConsumedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNSConsumedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNSConsumesSelfAttr(NSConsumesSelfAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNSConsumesSelfAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNSErrorDomainAttr(NSErrorDomainAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNSErrorDomainAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNSReturnsAutoreleasedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNSReturnsNotRetainedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNSReturnsRetainedAttr(NSReturnsRetainedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNSReturnsRetainedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNakedAttr(NakedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNakedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoAliasAttr(NoAliasAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoAliasAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoBuiltinAttr(NoBuiltinAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoBuiltinAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoCommonAttr(NoCommonAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoCommonAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoDebugAttr(NoDebugAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoDebugAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoDerefAttr(NoDerefAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoDerefAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoDestroyAttr(NoDestroyAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoDestroyAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoDuplicateAttr(NoDuplicateAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoDuplicateAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoEscapeAttr(NoEscapeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoEscapeAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoInlineAttr(NoInlineAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoInlineAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoInstrumentFunctionAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoMergeAttr(NoMergeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoMergeAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoMicroMipsAttr(NoMicroMipsAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoMicroMipsAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoMips16Attr(NoMips16Attr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoMips16Attr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoProfileFunctionAttr(NoProfileFunctionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoProfileFunctionAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoReturnAttr(NoReturnAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoReturnAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoSanitizeAttr(NoSanitizeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoSanitizeAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoSpeculativeLoadHardeningAttr(NoSpeculativeLoadHardeningAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoSpeculativeLoadHardeningAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoSplitStackAttr(NoSplitStackAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoSplitStackAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoStackProtectorAttr(NoStackProtectorAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoStackProtectorAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoThreadSafetyAnalysisAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoThrowAttr(NoThrowAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoThrowAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNoUniqueAddressAttr(NoUniqueAddressAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoUniqueAddressAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNonNullAttr(NonNullAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNonNullAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNotTailCalledAttr(NotTailCalledAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNotTailCalledAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOMPAllocateDeclAttr(OMPAllocateDeclAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOMPAllocateDeclAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getAllocator()))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOMPCaptureKindAttr(OMPCaptureKindAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOMPCaptureKindAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOMPCaptureNoInitAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOMPDeclareSimdDeclAttr(OMPDeclareSimdDeclAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOMPDeclareSimdDeclAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getSimdlen()))
    return false;
  {
    Expr * *I = A->uniforms_begin();
    Expr * *E = A->uniforms_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  {
    Expr * *I = A->aligneds_begin();
    Expr * *E = A->aligneds_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  {
    Expr * *I = A->alignments_begin();
    Expr * *E = A->alignments_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  {
    Expr * *I = A->linears_begin();
    Expr * *E = A->linears_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  {
    Expr * *I = A->steps_begin();
    Expr * *E = A->steps_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOMPDeclareTargetDeclAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOMPDeclareVariantAttr(OMPDeclareVariantAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOMPDeclareVariantAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getVariantFuncRef()))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOMPReferencedVarAttr(OMPReferencedVarAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOMPReferencedVarAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getRef()))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOMPThreadPrivateDeclAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOSConsumedAttr(OSConsumedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOSConsumedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOSConsumesThisAttr(OSConsumesThisAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOSConsumesThisAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOSReturnsNotRetainedAttr(OSReturnsNotRetainedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOSReturnsNotRetainedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOSReturnsRetainedAttr(OSReturnsRetainedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOSReturnsRetainedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOSReturnsRetainedOnNonZeroAttr(OSReturnsRetainedOnNonZeroAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOSReturnsRetainedOnNonZeroAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOSReturnsRetainedOnZeroAttr(OSReturnsRetainedOnZeroAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOSReturnsRetainedOnZeroAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCBoxableAttr(ObjCBoxableAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCBoxableAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCBridgeAttr(ObjCBridgeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCBridgeAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCBridgeMutableAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCBridgeRelatedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCClassStubAttr(ObjCClassStubAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCClassStubAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCDesignatedInitializerAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCDirectAttr(ObjCDirectAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCDirectAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCDirectMembersAttr(ObjCDirectMembersAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCDirectMembersAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCExceptionAttr(ObjCExceptionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCExceptionAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCExplicitProtocolImplAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCExternallyRetainedAttr(ObjCExternallyRetainedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCExternallyRetainedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCGCAttr(ObjCGCAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCGCAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCIndependentClassAttr(ObjCIndependentClassAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCIndependentClassAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCInertUnsafeUnretainedAttr(ObjCInertUnsafeUnretainedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCInertUnsafeUnretainedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCKindOfAttr(ObjCKindOfAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCKindOfAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCMethodFamilyAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCNSObjectAttr(ObjCNSObjectAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCNSObjectAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCNonLazyClassAttr(ObjCNonLazyClassAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCNonLazyClassAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCNonRuntimeProtocolAttr(ObjCNonRuntimeProtocolAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCNonRuntimeProtocolAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCOwnershipAttr(ObjCOwnershipAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCOwnershipAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCPreciseLifetimeAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCRequiresPropertyDefsAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCRequiresSuperAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCReturnsInnerPointerAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCRootClassAttr(ObjCRootClassAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCRootClassAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCRuntimeNameAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCRuntimeVisibleAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCSubclassingRestrictedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOpenCLAccessAttr(OpenCLAccessAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLAccessAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOpenCLConstantAddressSpaceAttr(OpenCLConstantAddressSpaceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLConstantAddressSpaceAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOpenCLGenericAddressSpaceAttr(OpenCLGenericAddressSpaceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLGenericAddressSpaceAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOpenCLGlobalAddressSpaceAttr(OpenCLGlobalAddressSpaceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLGlobalAddressSpaceAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOpenCLGlobalDeviceAddressSpaceAttr(OpenCLGlobalDeviceAddressSpaceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLGlobalDeviceAddressSpaceAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOpenCLGlobalHostAddressSpaceAttr(OpenCLGlobalHostAddressSpaceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLGlobalHostAddressSpaceAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLIntelReqdSubGroupSizeAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOpenCLKernelAttr(OpenCLKernelAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLKernelAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOpenCLLocalAddressSpaceAttr(OpenCLLocalAddressSpaceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLLocalAddressSpaceAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOpenCLPrivateAddressSpaceAttr(OpenCLPrivateAddressSpaceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLPrivateAddressSpaceAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLUnrollHintAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOptimizeNoneAttr(OptimizeNoneAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOptimizeNoneAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOverloadableAttr(OverloadableAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOverloadableAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOverrideAttr(OverrideAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOverrideAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOwnerAttr(OwnerAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOwnerAttr(A))
    return false;
  if (auto *TSI = A->getDerefTypeLoc())
    if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
      return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOwnershipAttr(OwnershipAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOwnershipAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraversePackedAttr(PackedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPackedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseParamTypestateAttr(ParamTypestateAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitParamTypestateAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraversePascalAttr(PascalAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPascalAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraversePassObjectSizeAttr(PassObjectSizeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPassObjectSizeAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraversePatchableFunctionEntryAttr(PatchableFunctionEntryAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPatchableFunctionEntryAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraversePcsAttr(PcsAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPcsAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraversePointerAttr(PointerAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPointerAttr(A))
    return false;
  if (auto *TSI = A->getDerefTypeLoc())
    if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
      return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraversePragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPragmaClangBSSSectionAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraversePragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPragmaClangDataSectionAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraversePragmaClangRelroSectionAttr(PragmaClangRelroSectionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPragmaClangRelroSectionAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraversePragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPragmaClangRodataSectionAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraversePragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPragmaClangTextSectionAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraversePreferredNameAttr(PreferredNameAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPreferredNameAttr(A))
    return false;
  if (auto *TSI = A->getTypedefTypeLoc())
    if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
      return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraversePreserveAllAttr(PreserveAllAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPreserveAllAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraversePreserveMostAttr(PreserveMostAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPreserveMostAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraversePtGuardedByAttr(PtGuardedByAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPtGuardedByAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getArg()))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraversePtGuardedVarAttr(PtGuardedVarAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPtGuardedVarAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraversePtr32Attr(Ptr32Attr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPtr32Attr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraversePtr64Attr(Ptr64Attr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPtr64Attr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraversePureAttr(PureAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPureAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseRISCVInterruptAttr(RISCVInterruptAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitRISCVInterruptAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseRegCallAttr(RegCallAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitRegCallAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseReinitializesAttr(ReinitializesAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitReinitializesAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseReleaseCapabilityAttr(ReleaseCapabilityAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitReleaseCapabilityAttr(A))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseReleaseHandleAttr(ReleaseHandleAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitReleaseHandleAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseRenderScriptKernelAttr(RenderScriptKernelAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitRenderScriptKernelAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitReqdWorkGroupSizeAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseRequiresCapabilityAttr(RequiresCapabilityAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitRequiresCapabilityAttr(A))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseRestrictAttr(RestrictAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitRestrictAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseRetainAttr(RetainAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitRetainAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseReturnTypestateAttr(ReturnTypestateAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitReturnTypestateAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseReturnsNonNullAttr(ReturnsNonNullAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitReturnsNonNullAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseReturnsTwiceAttr(ReturnsTwiceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitReturnsTwiceAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSPtrAttr(SPtrAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSPtrAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSYCLKernelAttr(SYCLKernelAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSYCLKernelAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseScopedLockableAttr(ScopedLockableAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitScopedLockableAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSectionAttr(SectionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSectionAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSelectAnyAttr(SelectAnyAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSelectAnyAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSentinelAttr(SentinelAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSentinelAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSetTypestateAttr(SetTypestateAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSetTypestateAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSharedTrylockFunctionAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getSuccessValue()))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSpeculativeLoadHardeningAttr(SpeculativeLoadHardeningAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSpeculativeLoadHardeningAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseStandaloneDebugAttr(StandaloneDebugAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitStandaloneDebugAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseStdCallAttr(StdCallAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitStdCallAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseStrictFPAttr(StrictFPAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitStrictFPAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSuppressAttr(SuppressAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSuppressAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSwiftAsyncAttr(SwiftAsyncAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftAsyncAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSwiftAsyncCallAttr(SwiftAsyncCallAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftAsyncCallAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSwiftAsyncContextAttr(SwiftAsyncContextAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftAsyncContextAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSwiftAsyncErrorAttr(SwiftAsyncErrorAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftAsyncErrorAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSwiftAsyncNameAttr(SwiftAsyncNameAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftAsyncNameAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSwiftAttrAttr(SwiftAttrAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftAttrAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSwiftBridgeAttr(SwiftBridgeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftBridgeAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSwiftBridgedTypedefAttr(SwiftBridgedTypedefAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftBridgedTypedefAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSwiftCallAttr(SwiftCallAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftCallAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSwiftContextAttr(SwiftContextAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftContextAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSwiftErrorAttr(SwiftErrorAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftErrorAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSwiftErrorResultAttr(SwiftErrorResultAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftErrorResultAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSwiftIndirectResultAttr(SwiftIndirectResultAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftIndirectResultAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSwiftNameAttr(SwiftNameAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftNameAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSwiftNewTypeAttr(SwiftNewTypeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftNewTypeAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSwiftObjCMembersAttr(SwiftObjCMembersAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftObjCMembersAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSwiftPrivateAttr(SwiftPrivateAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftPrivateAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSysVABIAttr(SysVABIAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSysVABIAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTLSModelAttr(TLSModelAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTLSModelAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTargetAttr(TargetAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTargetAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTestTypestateAttr(TestTypestateAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTestTypestateAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseThisCallAttr(ThisCallAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitThisCallAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseThreadAttr(ThreadAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitThreadAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTransparentUnionAttr(TransparentUnionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTransparentUnionAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTrivialABIAttr(TrivialABIAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTrivialABIAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTryAcquireCapabilityAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getSuccessValue()))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTypeNonNullAttr(TypeNonNullAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTypeNonNullAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTypeNullUnspecifiedAttr(TypeNullUnspecifiedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTypeNullUnspecifiedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTypeNullableAttr(TypeNullableAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTypeNullableAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTypeNullableResultAttr(TypeNullableResultAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTypeNullableResultAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTypeTagForDatatypeAttr(A))
    return false;
  if (auto *TSI = A->getMatchingCTypeLoc())
    if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
      return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTypeVisibilityAttr(TypeVisibilityAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTypeVisibilityAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseUPtrAttr(UPtrAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitUPtrAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseUnavailableAttr(UnavailableAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitUnavailableAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseUninitializedAttr(UninitializedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitUninitializedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseUnlikelyAttr(UnlikelyAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitUnlikelyAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseUnusedAttr(UnusedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitUnusedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseUseHandleAttr(UseHandleAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitUseHandleAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseUsedAttr(UsedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitUsedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseUsingIfExistsAttr(UsingIfExistsAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitUsingIfExistsAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseUuidAttr(UuidAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitUuidAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseVecReturnAttr(VecReturnAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitVecReturnAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseVecTypeHintAttr(VecTypeHintAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitVecTypeHintAttr(A))
    return false;
  if (auto *TSI = A->getTypeHintLoc())
    if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
      return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseVectorCallAttr(VectorCallAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitVectorCallAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseVisibilityAttr(VisibilityAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitVisibilityAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseWarnUnusedAttr(WarnUnusedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitWarnUnusedAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseWarnUnusedResultAttr(WarnUnusedResultAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitWarnUnusedResultAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseWeakAttr(WeakAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitWeakAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseWeakImportAttr(WeakImportAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitWeakImportAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseWeakRefAttr(WeakRefAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitWeakRefAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseWebAssemblyExportNameAttr(WebAssemblyExportNameAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitWebAssemblyExportNameAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseWebAssemblyImportModuleAttr(WebAssemblyImportModuleAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitWebAssemblyImportModuleAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseWebAssemblyImportNameAttr(WebAssemblyImportNameAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitWebAssemblyImportNameAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitWorkGroupSizeHintAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitX86ForceAlignArgPointerAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseXRayInstrumentAttr(XRayInstrumentAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitXRayInstrumentAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseXRayLogArgsAttr(XRayLogArgsAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitXRayLogArgsAttr(A))
    return false;
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseAttr(Attr *A) {
  if (!A)
    return true;
  switch (A->getKind()) {
    case attr::AArch64VectorPcs:
      return getDerived().TraverseAArch64VectorPcsAttr(cast<AArch64VectorPcsAttr>(A));
    case attr::AMDGPUFlatWorkGroupSize:
      return getDerived().TraverseAMDGPUFlatWorkGroupSizeAttr(cast<AMDGPUFlatWorkGroupSizeAttr>(A));
    case attr::AMDGPUNumSGPR:
      return getDerived().TraverseAMDGPUNumSGPRAttr(cast<AMDGPUNumSGPRAttr>(A));
    case attr::AMDGPUNumVGPR:
      return getDerived().TraverseAMDGPUNumVGPRAttr(cast<AMDGPUNumVGPRAttr>(A));
    case attr::AMDGPUWavesPerEU:
      return getDerived().TraverseAMDGPUWavesPerEUAttr(cast<AMDGPUWavesPerEUAttr>(A));
    case attr::ARMInterrupt:
      return getDerived().TraverseARMInterruptAttr(cast<ARMInterruptAttr>(A));
    case attr::AVRInterrupt:
      return getDerived().TraverseAVRInterruptAttr(cast<AVRInterruptAttr>(A));
    case attr::AVRSignal:
      return getDerived().TraverseAVRSignalAttr(cast<AVRSignalAttr>(A));
    case attr::AbiTag:
      return getDerived().TraverseAbiTagAttr(cast<AbiTagAttr>(A));
    case attr::AcquireCapability:
      return getDerived().TraverseAcquireCapabilityAttr(cast<AcquireCapabilityAttr>(A));
    case attr::AcquireHandle:
      return getDerived().TraverseAcquireHandleAttr(cast<AcquireHandleAttr>(A));
    case attr::AcquiredAfter:
      return getDerived().TraverseAcquiredAfterAttr(cast<AcquiredAfterAttr>(A));
    case attr::AcquiredBefore:
      return getDerived().TraverseAcquiredBeforeAttr(cast<AcquiredBeforeAttr>(A));
    case attr::AddressSpace:
      return getDerived().TraverseAddressSpaceAttr(cast<AddressSpaceAttr>(A));
    case attr::Alias:
      return getDerived().TraverseAliasAttr(cast<AliasAttr>(A));
    case attr::AlignMac68k:
      return getDerived().TraverseAlignMac68kAttr(cast<AlignMac68kAttr>(A));
    case attr::AlignNatural:
      return getDerived().TraverseAlignNaturalAttr(cast<AlignNaturalAttr>(A));
    case attr::AlignValue:
      return getDerived().TraverseAlignValueAttr(cast<AlignValueAttr>(A));
    case attr::Aligned:
      return getDerived().TraverseAlignedAttr(cast<AlignedAttr>(A));
    case attr::AllocAlign:
      return getDerived().TraverseAllocAlignAttr(cast<AllocAlignAttr>(A));
    case attr::AllocSize:
      return getDerived().TraverseAllocSizeAttr(cast<AllocSizeAttr>(A));
    case attr::AlwaysDestroy:
      return getDerived().TraverseAlwaysDestroyAttr(cast<AlwaysDestroyAttr>(A));
    case attr::AlwaysInline:
      return getDerived().TraverseAlwaysInlineAttr(cast<AlwaysInlineAttr>(A));
    case attr::AnalyzerNoReturn:
      return getDerived().TraverseAnalyzerNoReturnAttr(cast<AnalyzerNoReturnAttr>(A));
    case attr::Annotate:
      return getDerived().TraverseAnnotateAttr(cast<AnnotateAttr>(A));
    case attr::AnyX86Interrupt:
      return getDerived().TraverseAnyX86InterruptAttr(cast<AnyX86InterruptAttr>(A));
    case attr::AnyX86NoCallerSavedRegisters:
      return getDerived().TraverseAnyX86NoCallerSavedRegistersAttr(cast<AnyX86NoCallerSavedRegistersAttr>(A));
    case attr::AnyX86NoCfCheck:
      return getDerived().TraverseAnyX86NoCfCheckAttr(cast<AnyX86NoCfCheckAttr>(A));
    case attr::ArcWeakrefUnavailable:
      return getDerived().TraverseArcWeakrefUnavailableAttr(cast<ArcWeakrefUnavailableAttr>(A));
    case attr::ArgumentWithTypeTag:
      return getDerived().TraverseArgumentWithTypeTagAttr(cast<ArgumentWithTypeTagAttr>(A));
    case attr::ArmBuiltinAlias:
      return getDerived().TraverseArmBuiltinAliasAttr(cast<ArmBuiltinAliasAttr>(A));
    case attr::ArmMveStrictPolymorphism:
      return getDerived().TraverseArmMveStrictPolymorphismAttr(cast<ArmMveStrictPolymorphismAttr>(A));
    case attr::Artificial:
      return getDerived().TraverseArtificialAttr(cast<ArtificialAttr>(A));
    case attr::AsmLabel:
      return getDerived().TraverseAsmLabelAttr(cast<AsmLabelAttr>(A));
    case attr::AssertCapability:
      return getDerived().TraverseAssertCapabilityAttr(cast<AssertCapabilityAttr>(A));
    case attr::AssertExclusiveLock:
      return getDerived().TraverseAssertExclusiveLockAttr(cast<AssertExclusiveLockAttr>(A));
    case attr::AssertSharedLock:
      return getDerived().TraverseAssertSharedLockAttr(cast<AssertSharedLockAttr>(A));
    case attr::AssumeAligned:
      return getDerived().TraverseAssumeAlignedAttr(cast<AssumeAlignedAttr>(A));
    case attr::Assumption:
      return getDerived().TraverseAssumptionAttr(cast<AssumptionAttr>(A));
    case attr::Availability:
      return getDerived().TraverseAvailabilityAttr(cast<AvailabilityAttr>(A));
    case attr::BPFPreserveAccessIndex:
      return getDerived().TraverseBPFPreserveAccessIndexAttr(cast<BPFPreserveAccessIndexAttr>(A));
    case attr::Blocks:
      return getDerived().TraverseBlocksAttr(cast<BlocksAttr>(A));
    case attr::Builtin:
      return getDerived().TraverseBuiltinAttr(cast<BuiltinAttr>(A));
    case attr::BuiltinAlias:
      return getDerived().TraverseBuiltinAliasAttr(cast<BuiltinAliasAttr>(A));
    case attr::C11NoReturn:
      return getDerived().TraverseC11NoReturnAttr(cast<C11NoReturnAttr>(A));
    case attr::CDecl:
      return getDerived().TraverseCDeclAttr(cast<CDeclAttr>(A));
    case attr::CFAuditedTransfer:
      return getDerived().TraverseCFAuditedTransferAttr(cast<CFAuditedTransferAttr>(A));
    case attr::CFConsumed:
      return getDerived().TraverseCFConsumedAttr(cast<CFConsumedAttr>(A));
    case attr::CFGuard:
      return getDerived().TraverseCFGuardAttr(cast<CFGuardAttr>(A));
    case attr::CFICanonicalJumpTable:
      return getDerived().TraverseCFICanonicalJumpTableAttr(cast<CFICanonicalJumpTableAttr>(A));
    case attr::CFReturnsNotRetained:
      return getDerived().TraverseCFReturnsNotRetainedAttr(cast<CFReturnsNotRetainedAttr>(A));
    case attr::CFReturnsRetained:
      return getDerived().TraverseCFReturnsRetainedAttr(cast<CFReturnsRetainedAttr>(A));
    case attr::CFUnknownTransfer:
      return getDerived().TraverseCFUnknownTransferAttr(cast<CFUnknownTransferAttr>(A));
    case attr::CPUDispatch:
      return getDerived().TraverseCPUDispatchAttr(cast<CPUDispatchAttr>(A));
    case attr::CPUSpecific:
      return getDerived().TraverseCPUSpecificAttr(cast<CPUSpecificAttr>(A));
    case attr::CUDAConstant:
      return getDerived().TraverseCUDAConstantAttr(cast<CUDAConstantAttr>(A));
    case attr::CUDADevice:
      return getDerived().TraverseCUDADeviceAttr(cast<CUDADeviceAttr>(A));
    case attr::CUDADeviceBuiltinSurfaceType:
      return getDerived().TraverseCUDADeviceBuiltinSurfaceTypeAttr(cast<CUDADeviceBuiltinSurfaceTypeAttr>(A));
    case attr::CUDADeviceBuiltinTextureType:
      return getDerived().TraverseCUDADeviceBuiltinTextureTypeAttr(cast<CUDADeviceBuiltinTextureTypeAttr>(A));
    case attr::CUDAGlobal:
      return getDerived().TraverseCUDAGlobalAttr(cast<CUDAGlobalAttr>(A));
    case attr::CUDAHost:
      return getDerived().TraverseCUDAHostAttr(cast<CUDAHostAttr>(A));
    case attr::CUDAInvalidTarget:
      return getDerived().TraverseCUDAInvalidTargetAttr(cast<CUDAInvalidTargetAttr>(A));
    case attr::CUDALaunchBounds:
      return getDerived().TraverseCUDALaunchBoundsAttr(cast<CUDALaunchBoundsAttr>(A));
    case attr::CUDAShared:
      return getDerived().TraverseCUDASharedAttr(cast<CUDASharedAttr>(A));
    case attr::CXX11NoReturn:
      return getDerived().TraverseCXX11NoReturnAttr(cast<CXX11NoReturnAttr>(A));
    case attr::CallableWhen:
      return getDerived().TraverseCallableWhenAttr(cast<CallableWhenAttr>(A));
    case attr::Callback:
      return getDerived().TraverseCallbackAttr(cast<CallbackAttr>(A));
    case attr::CalledOnce:
      return getDerived().TraverseCalledOnceAttr(cast<CalledOnceAttr>(A));
    case attr::Capability:
      return getDerived().TraverseCapabilityAttr(cast<CapabilityAttr>(A));
    case attr::CapturedRecord:
      return getDerived().TraverseCapturedRecordAttr(cast<CapturedRecordAttr>(A));
    case attr::CarriesDependency:
      return getDerived().TraverseCarriesDependencyAttr(cast<CarriesDependencyAttr>(A));
    case attr::Cleanup:
      return getDerived().TraverseCleanupAttr(cast<CleanupAttr>(A));
    case attr::CmseNSCall:
      return getDerived().TraverseCmseNSCallAttr(cast<CmseNSCallAttr>(A));
    case attr::CmseNSEntry:
      return getDerived().TraverseCmseNSEntryAttr(cast<CmseNSEntryAttr>(A));
    case attr::CodeSeg:
      return getDerived().TraverseCodeSegAttr(cast<CodeSegAttr>(A));
    case attr::Cold:
      return getDerived().TraverseColdAttr(cast<ColdAttr>(A));
    case attr::Common:
      return getDerived().TraverseCommonAttr(cast<CommonAttr>(A));
    case attr::Const:
      return getDerived().TraverseConstAttr(cast<ConstAttr>(A));
    case attr::ConstInit:
      return getDerived().TraverseConstInitAttr(cast<ConstInitAttr>(A));
    case attr::Constructor:
      return getDerived().TraverseConstructorAttr(cast<ConstructorAttr>(A));
    case attr::Consumable:
      return getDerived().TraverseConsumableAttr(cast<ConsumableAttr>(A));
    case attr::ConsumableAutoCast:
      return getDerived().TraverseConsumableAutoCastAttr(cast<ConsumableAutoCastAttr>(A));
    case attr::ConsumableSetOnRead:
      return getDerived().TraverseConsumableSetOnReadAttr(cast<ConsumableSetOnReadAttr>(A));
    case attr::Convergent:
      return getDerived().TraverseConvergentAttr(cast<ConvergentAttr>(A));
    case attr::DLLExport:
      return getDerived().TraverseDLLExportAttr(cast<DLLExportAttr>(A));
    case attr::DLLExportStaticLocal:
      return getDerived().TraverseDLLExportStaticLocalAttr(cast<DLLExportStaticLocalAttr>(A));
    case attr::DLLImport:
      return getDerived().TraverseDLLImportAttr(cast<DLLImportAttr>(A));
    case attr::DLLImportStaticLocal:
      return getDerived().TraverseDLLImportStaticLocalAttr(cast<DLLImportStaticLocalAttr>(A));
    case attr::Deprecated:
      return getDerived().TraverseDeprecatedAttr(cast<DeprecatedAttr>(A));
    case attr::Destructor:
      return getDerived().TraverseDestructorAttr(cast<DestructorAttr>(A));
    case attr::DiagnoseIf:
      return getDerived().TraverseDiagnoseIfAttr(cast<DiagnoseIfAttr>(A));
    case attr::DisableTailCalls:
      return getDerived().TraverseDisableTailCallsAttr(cast<DisableTailCallsAttr>(A));
    case attr::EmptyBases:
      return getDerived().TraverseEmptyBasesAttr(cast<EmptyBasesAttr>(A));
    case attr::EnableIf:
      return getDerived().TraverseEnableIfAttr(cast<EnableIfAttr>(A));
    case attr::EnforceTCB:
      return getDerived().TraverseEnforceTCBAttr(cast<EnforceTCBAttr>(A));
    case attr::EnforceTCBLeaf:
      return getDerived().TraverseEnforceTCBLeafAttr(cast<EnforceTCBLeafAttr>(A));
    case attr::EnumExtensibility:
      return getDerived().TraverseEnumExtensibilityAttr(cast<EnumExtensibilityAttr>(A));
    case attr::ExcludeFromExplicitInstantiation:
      return getDerived().TraverseExcludeFromExplicitInstantiationAttr(cast<ExcludeFromExplicitInstantiationAttr>(A));
    case attr::ExclusiveTrylockFunction:
      return getDerived().TraverseExclusiveTrylockFunctionAttr(cast<ExclusiveTrylockFunctionAttr>(A));
    case attr::ExternalSourceSymbol:
      return getDerived().TraverseExternalSourceSymbolAttr(cast<ExternalSourceSymbolAttr>(A));
    case attr::FallThrough:
      return getDerived().TraverseFallThroughAttr(cast<FallThroughAttr>(A));
    case attr::FastCall:
      return getDerived().TraverseFastCallAttr(cast<FastCallAttr>(A));
    case attr::Final:
      return getDerived().TraverseFinalAttr(cast<FinalAttr>(A));
    case attr::FlagEnum:
      return getDerived().TraverseFlagEnumAttr(cast<FlagEnumAttr>(A));
    case attr::Flatten:
      return getDerived().TraverseFlattenAttr(cast<FlattenAttr>(A));
    case attr::Format:
      return getDerived().TraverseFormatAttr(cast<FormatAttr>(A));
    case attr::FormatArg:
      return getDerived().TraverseFormatArgAttr(cast<FormatArgAttr>(A));
    case attr::GNUInline:
      return getDerived().TraverseGNUInlineAttr(cast<GNUInlineAttr>(A));
    case attr::GuardedBy:
      return getDerived().TraverseGuardedByAttr(cast<GuardedByAttr>(A));
    case attr::GuardedVar:
      return getDerived().TraverseGuardedVarAttr(cast<GuardedVarAttr>(A));
    case attr::HIPManaged:
      return getDerived().TraverseHIPManagedAttr(cast<HIPManagedAttr>(A));
    case attr::Hot:
      return getDerived().TraverseHotAttr(cast<HotAttr>(A));
    case attr::IBAction:
      return getDerived().TraverseIBActionAttr(cast<IBActionAttr>(A));
    case attr::IBOutlet:
      return getDerived().TraverseIBOutletAttr(cast<IBOutletAttr>(A));
    case attr::IBOutletCollection:
      return getDerived().TraverseIBOutletCollectionAttr(cast<IBOutletCollectionAttr>(A));
    case attr::IFunc:
      return getDerived().TraverseIFuncAttr(cast<IFuncAttr>(A));
    case attr::InitPriority:
      return getDerived().TraverseInitPriorityAttr(cast<InitPriorityAttr>(A));
    case attr::InitSeg:
      return getDerived().TraverseInitSegAttr(cast<InitSegAttr>(A));
    case attr::IntelOclBicc:
      return getDerived().TraverseIntelOclBiccAttr(cast<IntelOclBiccAttr>(A));
    case attr::InternalLinkage:
      return getDerived().TraverseInternalLinkageAttr(cast<InternalLinkageAttr>(A));
    case attr::LTOVisibilityPublic:
      return getDerived().TraverseLTOVisibilityPublicAttr(cast<LTOVisibilityPublicAttr>(A));
    case attr::LayoutVersion:
      return getDerived().TraverseLayoutVersionAttr(cast<LayoutVersionAttr>(A));
    case attr::Leaf:
      return getDerived().TraverseLeafAttr(cast<LeafAttr>(A));
    case attr::LifetimeBound:
      return getDerived().TraverseLifetimeBoundAttr(cast<LifetimeBoundAttr>(A));
    case attr::Likely:
      return getDerived().TraverseLikelyAttr(cast<LikelyAttr>(A));
    case attr::LoaderUninitialized:
      return getDerived().TraverseLoaderUninitializedAttr(cast<LoaderUninitializedAttr>(A));
    case attr::LockReturned:
      return getDerived().TraverseLockReturnedAttr(cast<LockReturnedAttr>(A));
    case attr::LocksExcluded:
      return getDerived().TraverseLocksExcludedAttr(cast<LocksExcludedAttr>(A));
    case attr::LoopHint:
      return getDerived().TraverseLoopHintAttr(cast<LoopHintAttr>(A));
    case attr::M68kInterrupt:
      return getDerived().TraverseM68kInterruptAttr(cast<M68kInterruptAttr>(A));
    case attr::MIGServerRoutine:
      return getDerived().TraverseMIGServerRoutineAttr(cast<MIGServerRoutineAttr>(A));
    case attr::MSABI:
      return getDerived().TraverseMSABIAttr(cast<MSABIAttr>(A));
    case attr::MSAllocator:
      return getDerived().TraverseMSAllocatorAttr(cast<MSAllocatorAttr>(A));
    case attr::MSInheritance:
      return getDerived().TraverseMSInheritanceAttr(cast<MSInheritanceAttr>(A));
    case attr::MSNoVTable:
      return getDerived().TraverseMSNoVTableAttr(cast<MSNoVTableAttr>(A));
    case attr::MSP430Interrupt:
      return getDerived().TraverseMSP430InterruptAttr(cast<MSP430InterruptAttr>(A));
    case attr::MSStruct:
      return getDerived().TraverseMSStructAttr(cast<MSStructAttr>(A));
    case attr::MSVtorDisp:
      return getDerived().TraverseMSVtorDispAttr(cast<MSVtorDispAttr>(A));
    case attr::MaxFieldAlignment:
      return getDerived().TraverseMaxFieldAlignmentAttr(cast<MaxFieldAlignmentAttr>(A));
    case attr::MayAlias:
      return getDerived().TraverseMayAliasAttr(cast<MayAliasAttr>(A));
    case attr::MicroMips:
      return getDerived().TraverseMicroMipsAttr(cast<MicroMipsAttr>(A));
    case attr::MinSize:
      return getDerived().TraverseMinSizeAttr(cast<MinSizeAttr>(A));
    case attr::MinVectorWidth:
      return getDerived().TraverseMinVectorWidthAttr(cast<MinVectorWidthAttr>(A));
    case attr::Mips16:
      return getDerived().TraverseMips16Attr(cast<Mips16Attr>(A));
    case attr::MipsInterrupt:
      return getDerived().TraverseMipsInterruptAttr(cast<MipsInterruptAttr>(A));
    case attr::MipsLongCall:
      return getDerived().TraverseMipsLongCallAttr(cast<MipsLongCallAttr>(A));
    case attr::MipsShortCall:
      return getDerived().TraverseMipsShortCallAttr(cast<MipsShortCallAttr>(A));
    case attr::Mode:
      return getDerived().TraverseModeAttr(cast<ModeAttr>(A));
    case attr::MustTail:
      return getDerived().TraverseMustTailAttr(cast<MustTailAttr>(A));
    case attr::NSConsumed:
      return getDerived().TraverseNSConsumedAttr(cast<NSConsumedAttr>(A));
    case attr::NSConsumesSelf:
      return getDerived().TraverseNSConsumesSelfAttr(cast<NSConsumesSelfAttr>(A));
    case attr::NSErrorDomain:
      return getDerived().TraverseNSErrorDomainAttr(cast<NSErrorDomainAttr>(A));
    case attr::NSReturnsAutoreleased:
      return getDerived().TraverseNSReturnsAutoreleasedAttr(cast<NSReturnsAutoreleasedAttr>(A));
    case attr::NSReturnsNotRetained:
      return getDerived().TraverseNSReturnsNotRetainedAttr(cast<NSReturnsNotRetainedAttr>(A));
    case attr::NSReturnsRetained:
      return getDerived().TraverseNSReturnsRetainedAttr(cast<NSReturnsRetainedAttr>(A));
    case attr::Naked:
      return getDerived().TraverseNakedAttr(cast<NakedAttr>(A));
    case attr::NoAlias:
      return getDerived().TraverseNoAliasAttr(cast<NoAliasAttr>(A));
    case attr::NoBuiltin:
      return getDerived().TraverseNoBuiltinAttr(cast<NoBuiltinAttr>(A));
    case attr::NoCommon:
      return getDerived().TraverseNoCommonAttr(cast<NoCommonAttr>(A));
    case attr::NoDebug:
      return getDerived().TraverseNoDebugAttr(cast<NoDebugAttr>(A));
    case attr::NoDeref:
      return getDerived().TraverseNoDerefAttr(cast<NoDerefAttr>(A));
    case attr::NoDestroy:
      return getDerived().TraverseNoDestroyAttr(cast<NoDestroyAttr>(A));
    case attr::NoDuplicate:
      return getDerived().TraverseNoDuplicateAttr(cast<NoDuplicateAttr>(A));
    case attr::NoEscape:
      return getDerived().TraverseNoEscapeAttr(cast<NoEscapeAttr>(A));
    case attr::NoInline:
      return getDerived().TraverseNoInlineAttr(cast<NoInlineAttr>(A));
    case attr::NoInstrumentFunction:
      return getDerived().TraverseNoInstrumentFunctionAttr(cast<NoInstrumentFunctionAttr>(A));
    case attr::NoMerge:
      return getDerived().TraverseNoMergeAttr(cast<NoMergeAttr>(A));
    case attr::NoMicroMips:
      return getDerived().TraverseNoMicroMipsAttr(cast<NoMicroMipsAttr>(A));
    case attr::NoMips16:
      return getDerived().TraverseNoMips16Attr(cast<NoMips16Attr>(A));
    case attr::NoProfileFunction:
      return getDerived().TraverseNoProfileFunctionAttr(cast<NoProfileFunctionAttr>(A));
    case attr::NoReturn:
      return getDerived().TraverseNoReturnAttr(cast<NoReturnAttr>(A));
    case attr::NoSanitize:
      return getDerived().TraverseNoSanitizeAttr(cast<NoSanitizeAttr>(A));
    case attr::NoSpeculativeLoadHardening:
      return getDerived().TraverseNoSpeculativeLoadHardeningAttr(cast<NoSpeculativeLoadHardeningAttr>(A));
    case attr::NoSplitStack:
      return getDerived().TraverseNoSplitStackAttr(cast<NoSplitStackAttr>(A));
    case attr::NoStackProtector:
      return getDerived().TraverseNoStackProtectorAttr(cast<NoStackProtectorAttr>(A));
    case attr::NoThreadSafetyAnalysis:
      return getDerived().TraverseNoThreadSafetyAnalysisAttr(cast<NoThreadSafetyAnalysisAttr>(A));
    case attr::NoThrow:
      return getDerived().TraverseNoThrowAttr(cast<NoThrowAttr>(A));
    case attr::NoUniqueAddress:
      return getDerived().TraverseNoUniqueAddressAttr(cast<NoUniqueAddressAttr>(A));
    case attr::NonNull:
      return getDerived().TraverseNonNullAttr(cast<NonNullAttr>(A));
    case attr::NotTailCalled:
      return getDerived().TraverseNotTailCalledAttr(cast<NotTailCalledAttr>(A));
    case attr::OMPAllocateDecl:
      return getDerived().TraverseOMPAllocateDeclAttr(cast<OMPAllocateDeclAttr>(A));
    case attr::OMPCaptureKind:
      return getDerived().TraverseOMPCaptureKindAttr(cast<OMPCaptureKindAttr>(A));
    case attr::OMPCaptureNoInit:
      return getDerived().TraverseOMPCaptureNoInitAttr(cast<OMPCaptureNoInitAttr>(A));
    case attr::OMPDeclareSimdDecl:
      return getDerived().TraverseOMPDeclareSimdDeclAttr(cast<OMPDeclareSimdDeclAttr>(A));
    case attr::OMPDeclareTargetDecl:
      return getDerived().TraverseOMPDeclareTargetDeclAttr(cast<OMPDeclareTargetDeclAttr>(A));
    case attr::OMPDeclareVariant:
      return getDerived().TraverseOMPDeclareVariantAttr(cast<OMPDeclareVariantAttr>(A));
    case attr::OMPReferencedVar:
      return getDerived().TraverseOMPReferencedVarAttr(cast<OMPReferencedVarAttr>(A));
    case attr::OMPThreadPrivateDecl:
      return getDerived().TraverseOMPThreadPrivateDeclAttr(cast<OMPThreadPrivateDeclAttr>(A));
    case attr::OSConsumed:
      return getDerived().TraverseOSConsumedAttr(cast<OSConsumedAttr>(A));
    case attr::OSConsumesThis:
      return getDerived().TraverseOSConsumesThisAttr(cast<OSConsumesThisAttr>(A));
    case attr::OSReturnsNotRetained:
      return getDerived().TraverseOSReturnsNotRetainedAttr(cast<OSReturnsNotRetainedAttr>(A));
    case attr::OSReturnsRetained:
      return getDerived().TraverseOSReturnsRetainedAttr(cast<OSReturnsRetainedAttr>(A));
    case attr::OSReturnsRetainedOnNonZero:
      return getDerived().TraverseOSReturnsRetainedOnNonZeroAttr(cast<OSReturnsRetainedOnNonZeroAttr>(A));
    case attr::OSReturnsRetainedOnZero:
      return getDerived().TraverseOSReturnsRetainedOnZeroAttr(cast<OSReturnsRetainedOnZeroAttr>(A));
    case attr::ObjCBoxable:
      return getDerived().TraverseObjCBoxableAttr(cast<ObjCBoxableAttr>(A));
    case attr::ObjCBridge:
      return getDerived().TraverseObjCBridgeAttr(cast<ObjCBridgeAttr>(A));
    case attr::ObjCBridgeMutable:
      return getDerived().TraverseObjCBridgeMutableAttr(cast<ObjCBridgeMutableAttr>(A));
    case attr::ObjCBridgeRelated:
      return getDerived().TraverseObjCBridgeRelatedAttr(cast<ObjCBridgeRelatedAttr>(A));
    case attr::ObjCClassStub:
      return getDerived().TraverseObjCClassStubAttr(cast<ObjCClassStubAttr>(A));
    case attr::ObjCDesignatedInitializer:
      return getDerived().TraverseObjCDesignatedInitializerAttr(cast<ObjCDesignatedInitializerAttr>(A));
    case attr::ObjCDirect:
      return getDerived().TraverseObjCDirectAttr(cast<ObjCDirectAttr>(A));
    case attr::ObjCDirectMembers:
      return getDerived().TraverseObjCDirectMembersAttr(cast<ObjCDirectMembersAttr>(A));
    case attr::ObjCException:
      return getDerived().TraverseObjCExceptionAttr(cast<ObjCExceptionAttr>(A));
    case attr::ObjCExplicitProtocolImpl:
      return getDerived().TraverseObjCExplicitProtocolImplAttr(cast<ObjCExplicitProtocolImplAttr>(A));
    case attr::ObjCExternallyRetained:
      return getDerived().TraverseObjCExternallyRetainedAttr(cast<ObjCExternallyRetainedAttr>(A));
    case attr::ObjCGC:
      return getDerived().TraverseObjCGCAttr(cast<ObjCGCAttr>(A));
    case attr::ObjCIndependentClass:
      return getDerived().TraverseObjCIndependentClassAttr(cast<ObjCIndependentClassAttr>(A));
    case attr::ObjCInertUnsafeUnretained:
      return getDerived().TraverseObjCInertUnsafeUnretainedAttr(cast<ObjCInertUnsafeUnretainedAttr>(A));
    case attr::ObjCKindOf:
      return getDerived().TraverseObjCKindOfAttr(cast<ObjCKindOfAttr>(A));
    case attr::ObjCMethodFamily:
      return getDerived().TraverseObjCMethodFamilyAttr(cast<ObjCMethodFamilyAttr>(A));
    case attr::ObjCNSObject:
      return getDerived().TraverseObjCNSObjectAttr(cast<ObjCNSObjectAttr>(A));
    case attr::ObjCNonLazyClass:
      return getDerived().TraverseObjCNonLazyClassAttr(cast<ObjCNonLazyClassAttr>(A));
    case attr::ObjCNonRuntimeProtocol:
      return getDerived().TraverseObjCNonRuntimeProtocolAttr(cast<ObjCNonRuntimeProtocolAttr>(A));
    case attr::ObjCOwnership:
      return getDerived().TraverseObjCOwnershipAttr(cast<ObjCOwnershipAttr>(A));
    case attr::ObjCPreciseLifetime:
      return getDerived().TraverseObjCPreciseLifetimeAttr(cast<ObjCPreciseLifetimeAttr>(A));
    case attr::ObjCRequiresPropertyDefs:
      return getDerived().TraverseObjCRequiresPropertyDefsAttr(cast<ObjCRequiresPropertyDefsAttr>(A));
    case attr::ObjCRequiresSuper:
      return getDerived().TraverseObjCRequiresSuperAttr(cast<ObjCRequiresSuperAttr>(A));
    case attr::ObjCReturnsInnerPointer:
      return getDerived().TraverseObjCReturnsInnerPointerAttr(cast<ObjCReturnsInnerPointerAttr>(A));
    case attr::ObjCRootClass:
      return getDerived().TraverseObjCRootClassAttr(cast<ObjCRootClassAttr>(A));
    case attr::ObjCRuntimeName:
      return getDerived().TraverseObjCRuntimeNameAttr(cast<ObjCRuntimeNameAttr>(A));
    case attr::ObjCRuntimeVisible:
      return getDerived().TraverseObjCRuntimeVisibleAttr(cast<ObjCRuntimeVisibleAttr>(A));
    case attr::ObjCSubclassingRestricted:
      return getDerived().TraverseObjCSubclassingRestrictedAttr(cast<ObjCSubclassingRestrictedAttr>(A));
    case attr::OpenCLAccess:
      return getDerived().TraverseOpenCLAccessAttr(cast<OpenCLAccessAttr>(A));
    case attr::OpenCLConstantAddressSpace:
      return getDerived().TraverseOpenCLConstantAddressSpaceAttr(cast<OpenCLConstantAddressSpaceAttr>(A));
    case attr::OpenCLGenericAddressSpace:
      return getDerived().TraverseOpenCLGenericAddressSpaceAttr(cast<OpenCLGenericAddressSpaceAttr>(A));
    case attr::OpenCLGlobalAddressSpace:
      return getDerived().TraverseOpenCLGlobalAddressSpaceAttr(cast<OpenCLGlobalAddressSpaceAttr>(A));
    case attr::OpenCLGlobalDeviceAddressSpace:
      return getDerived().TraverseOpenCLGlobalDeviceAddressSpaceAttr(cast<OpenCLGlobalDeviceAddressSpaceAttr>(A));
    case attr::OpenCLGlobalHostAddressSpace:
      return getDerived().TraverseOpenCLGlobalHostAddressSpaceAttr(cast<OpenCLGlobalHostAddressSpaceAttr>(A));
    case attr::OpenCLIntelReqdSubGroupSize:
      return getDerived().TraverseOpenCLIntelReqdSubGroupSizeAttr(cast<OpenCLIntelReqdSubGroupSizeAttr>(A));
    case attr::OpenCLKernel:
      return getDerived().TraverseOpenCLKernelAttr(cast<OpenCLKernelAttr>(A));
    case attr::OpenCLLocalAddressSpace:
      return getDerived().TraverseOpenCLLocalAddressSpaceAttr(cast<OpenCLLocalAddressSpaceAttr>(A));
    case attr::OpenCLPrivateAddressSpace:
      return getDerived().TraverseOpenCLPrivateAddressSpaceAttr(cast<OpenCLPrivateAddressSpaceAttr>(A));
    case attr::OpenCLUnrollHint:
      return getDerived().TraverseOpenCLUnrollHintAttr(cast<OpenCLUnrollHintAttr>(A));
    case attr::OptimizeNone:
      return getDerived().TraverseOptimizeNoneAttr(cast<OptimizeNoneAttr>(A));
    case attr::Overloadable:
      return getDerived().TraverseOverloadableAttr(cast<OverloadableAttr>(A));
    case attr::Override:
      return getDerived().TraverseOverrideAttr(cast<OverrideAttr>(A));
    case attr::Owner:
      return getDerived().TraverseOwnerAttr(cast<OwnerAttr>(A));
    case attr::Ownership:
      return getDerived().TraverseOwnershipAttr(cast<OwnershipAttr>(A));
    case attr::Packed:
      return getDerived().TraversePackedAttr(cast<PackedAttr>(A));
    case attr::ParamTypestate:
      return getDerived().TraverseParamTypestateAttr(cast<ParamTypestateAttr>(A));
    case attr::Pascal:
      return getDerived().TraversePascalAttr(cast<PascalAttr>(A));
    case attr::PassObjectSize:
      return getDerived().TraversePassObjectSizeAttr(cast<PassObjectSizeAttr>(A));
    case attr::PatchableFunctionEntry:
      return getDerived().TraversePatchableFunctionEntryAttr(cast<PatchableFunctionEntryAttr>(A));
    case attr::Pcs:
      return getDerived().TraversePcsAttr(cast<PcsAttr>(A));
    case attr::Pointer:
      return getDerived().TraversePointerAttr(cast<PointerAttr>(A));
    case attr::PragmaClangBSSSection:
      return getDerived().TraversePragmaClangBSSSectionAttr(cast<PragmaClangBSSSectionAttr>(A));
    case attr::PragmaClangDataSection:
      return getDerived().TraversePragmaClangDataSectionAttr(cast<PragmaClangDataSectionAttr>(A));
    case attr::PragmaClangRelroSection:
      return getDerived().TraversePragmaClangRelroSectionAttr(cast<PragmaClangRelroSectionAttr>(A));
    case attr::PragmaClangRodataSection:
      return getDerived().TraversePragmaClangRodataSectionAttr(cast<PragmaClangRodataSectionAttr>(A));
    case attr::PragmaClangTextSection:
      return getDerived().TraversePragmaClangTextSectionAttr(cast<PragmaClangTextSectionAttr>(A));
    case attr::PreferredName:
      return getDerived().TraversePreferredNameAttr(cast<PreferredNameAttr>(A));
    case attr::PreserveAll:
      return getDerived().TraversePreserveAllAttr(cast<PreserveAllAttr>(A));
    case attr::PreserveMost:
      return getDerived().TraversePreserveMostAttr(cast<PreserveMostAttr>(A));
    case attr::PtGuardedBy:
      return getDerived().TraversePtGuardedByAttr(cast<PtGuardedByAttr>(A));
    case attr::PtGuardedVar:
      return getDerived().TraversePtGuardedVarAttr(cast<PtGuardedVarAttr>(A));
    case attr::Ptr32:
      return getDerived().TraversePtr32Attr(cast<Ptr32Attr>(A));
    case attr::Ptr64:
      return getDerived().TraversePtr64Attr(cast<Ptr64Attr>(A));
    case attr::Pure:
      return getDerived().TraversePureAttr(cast<PureAttr>(A));
    case attr::RISCVInterrupt:
      return getDerived().TraverseRISCVInterruptAttr(cast<RISCVInterruptAttr>(A));
    case attr::RegCall:
      return getDerived().TraverseRegCallAttr(cast<RegCallAttr>(A));
    case attr::Reinitializes:
      return getDerived().TraverseReinitializesAttr(cast<ReinitializesAttr>(A));
    case attr::ReleaseCapability:
      return getDerived().TraverseReleaseCapabilityAttr(cast<ReleaseCapabilityAttr>(A));
    case attr::ReleaseHandle:
      return getDerived().TraverseReleaseHandleAttr(cast<ReleaseHandleAttr>(A));
    case attr::RenderScriptKernel:
      return getDerived().TraverseRenderScriptKernelAttr(cast<RenderScriptKernelAttr>(A));
    case attr::ReqdWorkGroupSize:
      return getDerived().TraverseReqdWorkGroupSizeAttr(cast<ReqdWorkGroupSizeAttr>(A));
    case attr::RequiresCapability:
      return getDerived().TraverseRequiresCapabilityAttr(cast<RequiresCapabilityAttr>(A));
    case attr::Restrict:
      return getDerived().TraverseRestrictAttr(cast<RestrictAttr>(A));
    case attr::Retain:
      return getDerived().TraverseRetainAttr(cast<RetainAttr>(A));
    case attr::ReturnTypestate:
      return getDerived().TraverseReturnTypestateAttr(cast<ReturnTypestateAttr>(A));
    case attr::ReturnsNonNull:
      return getDerived().TraverseReturnsNonNullAttr(cast<ReturnsNonNullAttr>(A));
    case attr::ReturnsTwice:
      return getDerived().TraverseReturnsTwiceAttr(cast<ReturnsTwiceAttr>(A));
    case attr::SPtr:
      return getDerived().TraverseSPtrAttr(cast<SPtrAttr>(A));
    case attr::SYCLKernel:
      return getDerived().TraverseSYCLKernelAttr(cast<SYCLKernelAttr>(A));
    case attr::ScopedLockable:
      return getDerived().TraverseScopedLockableAttr(cast<ScopedLockableAttr>(A));
    case attr::Section:
      return getDerived().TraverseSectionAttr(cast<SectionAttr>(A));
    case attr::SelectAny:
      return getDerived().TraverseSelectAnyAttr(cast<SelectAnyAttr>(A));
    case attr::Sentinel:
      return getDerived().TraverseSentinelAttr(cast<SentinelAttr>(A));
    case attr::SetTypestate:
      return getDerived().TraverseSetTypestateAttr(cast<SetTypestateAttr>(A));
    case attr::SharedTrylockFunction:
      return getDerived().TraverseSharedTrylockFunctionAttr(cast<SharedTrylockFunctionAttr>(A));
    case attr::SpeculativeLoadHardening:
      return getDerived().TraverseSpeculativeLoadHardeningAttr(cast<SpeculativeLoadHardeningAttr>(A));
    case attr::StandaloneDebug:
      return getDerived().TraverseStandaloneDebugAttr(cast<StandaloneDebugAttr>(A));
    case attr::StdCall:
      return getDerived().TraverseStdCallAttr(cast<StdCallAttr>(A));
    case attr::StrictFP:
      return getDerived().TraverseStrictFPAttr(cast<StrictFPAttr>(A));
    case attr::Suppress:
      return getDerived().TraverseSuppressAttr(cast<SuppressAttr>(A));
    case attr::SwiftAsync:
      return getDerived().TraverseSwiftAsyncAttr(cast<SwiftAsyncAttr>(A));
    case attr::SwiftAsyncCall:
      return getDerived().TraverseSwiftAsyncCallAttr(cast<SwiftAsyncCallAttr>(A));
    case attr::SwiftAsyncContext:
      return getDerived().TraverseSwiftAsyncContextAttr(cast<SwiftAsyncContextAttr>(A));
    case attr::SwiftAsyncError:
      return getDerived().TraverseSwiftAsyncErrorAttr(cast<SwiftAsyncErrorAttr>(A));
    case attr::SwiftAsyncName:
      return getDerived().TraverseSwiftAsyncNameAttr(cast<SwiftAsyncNameAttr>(A));
    case attr::SwiftAttr:
      return getDerived().TraverseSwiftAttrAttr(cast<SwiftAttrAttr>(A));
    case attr::SwiftBridge:
      return getDerived().TraverseSwiftBridgeAttr(cast<SwiftBridgeAttr>(A));
    case attr::SwiftBridgedTypedef:
      return getDerived().TraverseSwiftBridgedTypedefAttr(cast<SwiftBridgedTypedefAttr>(A));
    case attr::SwiftCall:
      return getDerived().TraverseSwiftCallAttr(cast<SwiftCallAttr>(A));
    case attr::SwiftContext:
      return getDerived().TraverseSwiftContextAttr(cast<SwiftContextAttr>(A));
    case attr::SwiftError:
      return getDerived().TraverseSwiftErrorAttr(cast<SwiftErrorAttr>(A));
    case attr::SwiftErrorResult:
      return getDerived().TraverseSwiftErrorResultAttr(cast<SwiftErrorResultAttr>(A));
    case attr::SwiftIndirectResult:
      return getDerived().TraverseSwiftIndirectResultAttr(cast<SwiftIndirectResultAttr>(A));
    case attr::SwiftName:
      return getDerived().TraverseSwiftNameAttr(cast<SwiftNameAttr>(A));
    case attr::SwiftNewType:
      return getDerived().TraverseSwiftNewTypeAttr(cast<SwiftNewTypeAttr>(A));
    case attr::SwiftObjCMembers:
      return getDerived().TraverseSwiftObjCMembersAttr(cast<SwiftObjCMembersAttr>(A));
    case attr::SwiftPrivate:
      return getDerived().TraverseSwiftPrivateAttr(cast<SwiftPrivateAttr>(A));
    case attr::SysVABI:
      return getDerived().TraverseSysVABIAttr(cast<SysVABIAttr>(A));
    case attr::TLSModel:
      return getDerived().TraverseTLSModelAttr(cast<TLSModelAttr>(A));
    case attr::Target:
      return getDerived().TraverseTargetAttr(cast<TargetAttr>(A));
    case attr::TestTypestate:
      return getDerived().TraverseTestTypestateAttr(cast<TestTypestateAttr>(A));
    case attr::ThisCall:
      return getDerived().TraverseThisCallAttr(cast<ThisCallAttr>(A));
    case attr::Thread:
      return getDerived().TraverseThreadAttr(cast<ThreadAttr>(A));
    case attr::TransparentUnion:
      return getDerived().TraverseTransparentUnionAttr(cast<TransparentUnionAttr>(A));
    case attr::TrivialABI:
      return getDerived().TraverseTrivialABIAttr(cast<TrivialABIAttr>(A));
    case attr::TryAcquireCapability:
      return getDerived().TraverseTryAcquireCapabilityAttr(cast<TryAcquireCapabilityAttr>(A));
    case attr::TypeNonNull:
      return getDerived().TraverseTypeNonNullAttr(cast<TypeNonNullAttr>(A));
    case attr::TypeNullUnspecified:
      return getDerived().TraverseTypeNullUnspecifiedAttr(cast<TypeNullUnspecifiedAttr>(A));
    case attr::TypeNullable:
      return getDerived().TraverseTypeNullableAttr(cast<TypeNullableAttr>(A));
    case attr::TypeNullableResult:
      return getDerived().TraverseTypeNullableResultAttr(cast<TypeNullableResultAttr>(A));
    case attr::TypeTagForDatatype:
      return getDerived().TraverseTypeTagForDatatypeAttr(cast<TypeTagForDatatypeAttr>(A));
    case attr::TypeVisibility:
      return getDerived().TraverseTypeVisibilityAttr(cast<TypeVisibilityAttr>(A));
    case attr::UPtr:
      return getDerived().TraverseUPtrAttr(cast<UPtrAttr>(A));
    case attr::Unavailable:
      return getDerived().TraverseUnavailableAttr(cast<UnavailableAttr>(A));
    case attr::Uninitialized:
      return getDerived().TraverseUninitializedAttr(cast<UninitializedAttr>(A));
    case attr::Unlikely:
      return getDerived().TraverseUnlikelyAttr(cast<UnlikelyAttr>(A));
    case attr::Unused:
      return getDerived().TraverseUnusedAttr(cast<UnusedAttr>(A));
    case attr::UseHandle:
      return getDerived().TraverseUseHandleAttr(cast<UseHandleAttr>(A));
    case attr::Used:
      return getDerived().TraverseUsedAttr(cast<UsedAttr>(A));
    case attr::UsingIfExists:
      return getDerived().TraverseUsingIfExistsAttr(cast<UsingIfExistsAttr>(A));
    case attr::Uuid:
      return getDerived().TraverseUuidAttr(cast<UuidAttr>(A));
    case attr::VecReturn:
      return getDerived().TraverseVecReturnAttr(cast<VecReturnAttr>(A));
    case attr::VecTypeHint:
      return getDerived().TraverseVecTypeHintAttr(cast<VecTypeHintAttr>(A));
    case attr::VectorCall:
      return getDerived().TraverseVectorCallAttr(cast<VectorCallAttr>(A));
    case attr::Visibility:
      return getDerived().TraverseVisibilityAttr(cast<VisibilityAttr>(A));
    case attr::WarnUnused:
      return getDerived().TraverseWarnUnusedAttr(cast<WarnUnusedAttr>(A));
    case attr::WarnUnusedResult:
      return getDerived().TraverseWarnUnusedResultAttr(cast<WarnUnusedResultAttr>(A));
    case attr::Weak:
      return getDerived().TraverseWeakAttr(cast<WeakAttr>(A));
    case attr::WeakImport:
      return getDerived().TraverseWeakImportAttr(cast<WeakImportAttr>(A));
    case attr::WeakRef:
      return getDerived().TraverseWeakRefAttr(cast<WeakRefAttr>(A));
    case attr::WebAssemblyExportName:
      return getDerived().TraverseWebAssemblyExportNameAttr(cast<WebAssemblyExportNameAttr>(A));
    case attr::WebAssemblyImportModule:
      return getDerived().TraverseWebAssemblyImportModuleAttr(cast<WebAssemblyImportModuleAttr>(A));
    case attr::WebAssemblyImportName:
      return getDerived().TraverseWebAssemblyImportNameAttr(cast<WebAssemblyImportNameAttr>(A));
    case attr::WorkGroupSizeHint:
      return getDerived().TraverseWorkGroupSizeHintAttr(cast<WorkGroupSizeHintAttr>(A));
    case attr::X86ForceAlignArgPointer:
      return getDerived().TraverseX86ForceAlignArgPointerAttr(cast<X86ForceAlignArgPointerAttr>(A));
    case attr::XRayInstrument:
      return getDerived().TraverseXRayInstrumentAttr(cast<XRayInstrumentAttr>(A));
    case attr::XRayLogArgs:
      return getDerived().TraverseXRayLogArgsAttr(cast<XRayLogArgsAttr>(A));
  }
  ::llvm::llvm_unreachable_internal("bad attribute kind", "/Users/viton/PrivateProject/LLVM/llvm-project/.build_RelWithDebInfo/tools/clang/include/clang/AST/AttrVisitor.inc", 5349);
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseDecl(Decl *D) {
  if (!D)
    return true;
  if (!getDerived().shouldVisitImplicitCode() && D->isImplicit()) {
    if (auto *TTPD = dyn_cast<TemplateTypeParmDecl>(D))
      return TraverseTemplateTypeParamDeclConstraints(TTPD);
    return true;
  }
  switch (D->getKind()) {
case Decl::AccessSpec: if (!getDerived().TraverseAccessSpecDecl(static_cast<AccessSpecDecl *>(D))) return false; break;
case Decl::Block: if (!getDerived().TraverseBlockDecl(static_cast<BlockDecl *>(D))) return false; break;
case Decl::Captured: if (!getDerived().TraverseCapturedDecl(static_cast<CapturedDecl *>(D))) return false; break;
case Decl::ClassScopeFunctionSpecialization: if (!getDerived().TraverseClassScopeFunctionSpecializationDecl(static_cast<ClassScopeFunctionSpecializationDecl *>(D))) return false; break;
case Decl::Empty: if (!getDerived().TraverseEmptyDecl(static_cast<EmptyDecl *>(D))) return false; break;
case Decl::Export: if (!getDerived().TraverseExportDecl(static_cast<ExportDecl *>(D))) return false; break;
case Decl::ExternCContext: if (!getDerived().TraverseExternCContextDecl(static_cast<ExternCContextDecl *>(D))) return false; break;
case Decl::FileScopeAsm: if (!getDerived().TraverseFileScopeAsmDecl(static_cast<FileScopeAsmDecl *>(D))) return false; break;
case Decl::Friend: if (!getDerived().TraverseFriendDecl(static_cast<FriendDecl *>(D))) return false; break;
case Decl::FriendTemplate: if (!getDerived().TraverseFriendTemplateDecl(static_cast<FriendTemplateDecl *>(D))) return false; break;
case Decl::Import: if (!getDerived().TraverseImportDecl(static_cast<ImportDecl *>(D))) return false; break;
case Decl::LifetimeExtendedTemporary: if (!getDerived().TraverseLifetimeExtendedTemporaryDecl(static_cast<LifetimeExtendedTemporaryDecl *>(D))) return false; break;
case Decl::LinkageSpec: if (!getDerived().TraverseLinkageSpecDecl(static_cast<LinkageSpecDecl *>(D))) return false; break;
case Decl::Using: if (!getDerived().TraverseUsingDecl(static_cast<UsingDecl *>(D))) return false; break;
case Decl::UsingEnum: if (!getDerived().TraverseUsingEnumDecl(static_cast<UsingEnumDecl *>(D))) return false; break;
case Decl::Label: if (!getDerived().TraverseLabelDecl(static_cast<LabelDecl *>(D))) return false; break;
case Decl::Namespace: if (!getDerived().TraverseNamespaceDecl(static_cast<NamespaceDecl *>(D))) return false; break;
case Decl::NamespaceAlias: if (!getDerived().TraverseNamespaceAliasDecl(static_cast<NamespaceAliasDecl *>(D))) return false; break;
case Decl::ObjCCompatibleAlias: if (!getDerived().TraverseObjCCompatibleAliasDecl(static_cast<ObjCCompatibleAliasDecl *>(D))) return false; break;
case Decl::ObjCCategory: if (!getDerived().TraverseObjCCategoryDecl(static_cast<ObjCCategoryDecl *>(D))) return false; break;
case Decl::ObjCCategoryImpl: if (!getDerived().TraverseObjCCategoryImplDecl(static_cast<ObjCCategoryImplDecl *>(D))) return false; break;
case Decl::ObjCImplementation: if (!getDerived().TraverseObjCImplementationDecl(static_cast<ObjCImplementationDecl *>(D))) return false; break;
case Decl::ObjCInterface: if (!getDerived().TraverseObjCInterfaceDecl(static_cast<ObjCInterfaceDecl *>(D))) return false; break;
case Decl::ObjCProtocol: if (!getDerived().TraverseObjCProtocolDecl(static_cast<ObjCProtocolDecl *>(D))) return false; break;
case Decl::ObjCMethod: if (!getDerived().TraverseObjCMethodDecl(static_cast<ObjCMethodDecl *>(D))) return false; break;
case Decl::ObjCProperty: if (!getDerived().TraverseObjCPropertyDecl(static_cast<ObjCPropertyDecl *>(D))) return false; break;
case Decl::BuiltinTemplate: if (!getDerived().TraverseBuiltinTemplateDecl(static_cast<BuiltinTemplateDecl *>(D))) return false; break;
case Decl::Concept: if (!getDerived().TraverseConceptDecl(static_cast<ConceptDecl *>(D))) return false; break;
case Decl::ClassTemplate: if (!getDerived().TraverseClassTemplateDecl(static_cast<ClassTemplateDecl *>(D))) return false; break;
case Decl::FunctionTemplate: if (!getDerived().TraverseFunctionTemplateDecl(static_cast<FunctionTemplateDecl *>(D))) return false; break;
case Decl::TypeAliasTemplate: if (!getDerived().TraverseTypeAliasTemplateDecl(static_cast<TypeAliasTemplateDecl *>(D))) return false; break;
case Decl::VarTemplate: if (!getDerived().TraverseVarTemplateDecl(static_cast<VarTemplateDecl *>(D))) return false; break;
case Decl::TemplateTemplateParm: if (!getDerived().TraverseTemplateTemplateParmDecl(static_cast<TemplateTemplateParmDecl *>(D))) return false; break;
case Decl::Enum: if (!getDerived().TraverseEnumDecl(static_cast<EnumDecl *>(D))) return false; break;
case Decl::Record: if (!getDerived().TraverseRecordDecl(static_cast<RecordDecl *>(D))) return false; break;
case Decl::CXXRecord: if (!getDerived().TraverseCXXRecordDecl(static_cast<CXXRecordDecl *>(D))) return false; break;
case Decl::ClassTemplateSpecialization: if (!getDerived().TraverseClassTemplateSpecializationDecl(static_cast<ClassTemplateSpecializationDecl *>(D))) return false; break;
case Decl::ClassTemplatePartialSpecialization: if (!getDerived().TraverseClassTemplatePartialSpecializationDecl(static_cast<ClassTemplatePartialSpecializationDecl *>(D))) return false; break;
case Decl::TemplateTypeParm: if (!getDerived().TraverseTemplateTypeParmDecl(static_cast<TemplateTypeParmDecl *>(D))) return false; break;
case Decl::ObjCTypeParam: if (!getDerived().TraverseObjCTypeParamDecl(static_cast<ObjCTypeParamDecl *>(D))) return false; break;
case Decl::TypeAlias: if (!getDerived().TraverseTypeAliasDecl(static_cast<TypeAliasDecl *>(D))) return false; break;
case Decl::Typedef: if (!getDerived().TraverseTypedefDecl(static_cast<TypedefDecl *>(D))) return false; break;
case Decl::UnresolvedUsingTypename: if (!getDerived().TraverseUnresolvedUsingTypenameDecl(static_cast<UnresolvedUsingTypenameDecl *>(D))) return false; break;
case Decl::UnresolvedUsingIfExists: if (!getDerived().TraverseUnresolvedUsingIfExistsDecl(static_cast<UnresolvedUsingIfExistsDecl *>(D))) return false; break;
case Decl::UsingDirective: if (!getDerived().TraverseUsingDirectiveDecl(static_cast<UsingDirectiveDecl *>(D))) return false; break;
case Decl::UsingPack: if (!getDerived().TraverseUsingPackDecl(static_cast<UsingPackDecl *>(D))) return false; break;
case Decl::UsingShadow: if (!getDerived().TraverseUsingShadowDecl(static_cast<UsingShadowDecl *>(D))) return false; break;
case Decl::ConstructorUsingShadow: if (!getDerived().TraverseConstructorUsingShadowDecl(static_cast<ConstructorUsingShadowDecl *>(D))) return false; break;
case Decl::Binding: if (!getDerived().TraverseBindingDecl(static_cast<BindingDecl *>(D))) return false; break;
case Decl::Field: if (!getDerived().TraverseFieldDecl(static_cast<FieldDecl *>(D))) return false; break;
case Decl::ObjCAtDefsField: if (!getDerived().TraverseObjCAtDefsFieldDecl(static_cast<ObjCAtDefsFieldDecl *>(D))) return false; break;
case Decl::ObjCIvar: if (!getDerived().TraverseObjCIvarDecl(static_cast<ObjCIvarDecl *>(D))) return false; break;
case Decl::Function: if (!getDerived().TraverseFunctionDecl(static_cast<FunctionDecl *>(D))) return false; break;
case Decl::CXXDeductionGuide: if (!getDerived().TraverseCXXDeductionGuideDecl(static_cast<CXXDeductionGuideDecl *>(D))) return false; break;
case Decl::CXXMethod: if (!getDerived().TraverseCXXMethodDecl(static_cast<CXXMethodDecl *>(D))) return false; break;
case Decl::CXXConstructor: if (!getDerived().TraverseCXXConstructorDecl(static_cast<CXXConstructorDecl *>(D))) return false; break;
case Decl::CXXConversion: if (!getDerived().TraverseCXXConversionDecl(static_cast<CXXConversionDecl *>(D))) return false; break;
case Decl::CXXDestructor: if (!getDerived().TraverseCXXDestructorDecl(static_cast<CXXDestructorDecl *>(D))) return false; break;
case Decl::MSProperty: if (!getDerived().TraverseMSPropertyDecl(static_cast<MSPropertyDecl *>(D))) return false; break;
case Decl::NonTypeTemplateParm: if (!getDerived().TraverseNonTypeTemplateParmDecl(static_cast<NonTypeTemplateParmDecl *>(D))) return false; break;
case Decl::Var: if (!getDerived().TraverseVarDecl(static_cast<VarDecl *>(D))) return false; break;
case Decl::Decomposition: if (!getDerived().TraverseDecompositionDecl(static_cast<DecompositionDecl *>(D))) return false; break;
case Decl::ImplicitParam: if (!getDerived().TraverseImplicitParamDecl(static_cast<ImplicitParamDecl *>(D))) return false; break;
case Decl::OMPCapturedExpr: if (!getDerived().TraverseOMPCapturedExprDecl(static_cast<OMPCapturedExprDecl *>(D))) return false; break;
case Decl::ParmVar: if (!getDerived().TraverseParmVarDecl(static_cast<ParmVarDecl *>(D))) return false; break;
case Decl::VarTemplateSpecialization: if (!getDerived().TraverseVarTemplateSpecializationDecl(static_cast<VarTemplateSpecializationDecl *>(D))) return false; break;
case Decl::VarTemplatePartialSpecialization: if (!getDerived().TraverseVarTemplatePartialSpecializationDecl(static_cast<VarTemplatePartialSpecializationDecl *>(D))) return false; break;
case Decl::EnumConstant: if (!getDerived().TraverseEnumConstantDecl(static_cast<EnumConstantDecl *>(D))) return false; break;
case Decl::IndirectField: if (!getDerived().TraverseIndirectFieldDecl(static_cast<IndirectFieldDecl *>(D))) return false; break;
case Decl::MSGuid: if (!getDerived().TraverseMSGuidDecl(static_cast<MSGuidDecl *>(D))) return false; break;
case Decl::OMPDeclareMapper: if (!getDerived().TraverseOMPDeclareMapperDecl(static_cast<OMPDeclareMapperDecl *>(D))) return false; break;
case Decl::OMPDeclareReduction: if (!getDerived().TraverseOMPDeclareReductionDecl(static_cast<OMPDeclareReductionDecl *>(D))) return false; break;
case Decl::TemplateParamObject: if (!getDerived().TraverseTemplateParamObjectDecl(static_cast<TemplateParamObjectDecl *>(D))) return false; break;
case Decl::UnresolvedUsingValue: if (!getDerived().TraverseUnresolvedUsingValueDecl(static_cast<UnresolvedUsingValueDecl *>(D))) return false; break;
case Decl::OMPAllocate: if (!getDerived().TraverseOMPAllocateDecl(static_cast<OMPAllocateDecl *>(D))) return false; break;
case Decl::OMPRequires: if (!getDerived().TraverseOMPRequiresDecl(static_cast<OMPRequiresDecl *>(D))) return false; break;
case Decl::OMPThreadPrivate: if (!getDerived().TraverseOMPThreadPrivateDecl(static_cast<OMPThreadPrivateDecl *>(D))) return false; break;
case Decl::ObjCPropertyImpl: if (!getDerived().TraverseObjCPropertyImplDecl(static_cast<ObjCPropertyImplDecl *>(D))) return false; break;
case Decl::PragmaComment: if (!getDerived().TraversePragmaCommentDecl(static_cast<PragmaCommentDecl *>(D))) return false; break;
case Decl::PragmaDetectMismatch: if (!getDerived().TraversePragmaDetectMismatchDecl(static_cast<PragmaDetectMismatchDecl *>(D))) return false; break;
case Decl::RequiresExprBody: if (!getDerived().TraverseRequiresExprBodyDecl(static_cast<RequiresExprBodyDecl *>(D))) return false; break;
case Decl::StaticAssert: if (!getDerived().TraverseStaticAssertDecl(static_cast<StaticAssertDecl *>(D))) return false; break;
case Decl::TranslationUnit: if (!getDerived().TraverseTranslationUnitDecl(static_cast<TranslationUnitDecl *>(D))) return false; break;
 }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNestedNameSpecifier(
    NestedNameSpecifier *NNS) {
  if (!NNS)
    return true;
  if (NNS->getPrefix())
    do { if (!getDerived().TraverseNestedNameSpecifier(NNS->getPrefix())) return false; } while (false);
  switch (NNS->getKind()) {
  case NestedNameSpecifier::Identifier:
  case NestedNameSpecifier::Namespace:
  case NestedNameSpecifier::NamespaceAlias:
  case NestedNameSpecifier::Global:
  case NestedNameSpecifier::Super:
    return true;
  case NestedNameSpecifier::TypeSpec:
  case NestedNameSpecifier::TypeSpecWithTemplate:
    do { if (!getDerived().TraverseType(QualType(NNS->getAsType(), 0))) return false; } while (false);
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseNestedNameSpecifierLoc(
    NestedNameSpecifierLoc NNS) {
  if (!NNS)
    return true;
  if (NestedNameSpecifierLoc Prefix = NNS.getPrefix())
    do { if (!getDerived().TraverseNestedNameSpecifierLoc(Prefix)) return false; } while (false);
  switch (NNS.getNestedNameSpecifier()->getKind()) {
  case NestedNameSpecifier::Identifier:
  case NestedNameSpecifier::Namespace:
  case NestedNameSpecifier::NamespaceAlias:
  case NestedNameSpecifier::Global:
  case NestedNameSpecifier::Super:
    return true;
  case NestedNameSpecifier::TypeSpec:
  case NestedNameSpecifier::TypeSpecWithTemplate:
    do { if (!getDerived().TraverseTypeLoc(NNS.getTypeLoc())) return false; } while (false);
    break;
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseDeclarationNameInfo(
    DeclarationNameInfo NameInfo) {
  switch (NameInfo.getName().getNameKind()) {
  case DeclarationName::CXXConstructorName:
  case DeclarationName::CXXDestructorName:
  case DeclarationName::CXXConversionFunctionName:
    if (TypeSourceInfo *TSInfo = NameInfo.getNamedTypeInfo())
      do { if (!getDerived().TraverseTypeLoc(TSInfo->getTypeLoc())) return false; } while (false);
    break;
  case DeclarationName::CXXDeductionGuideName:
    do { if (!getDerived().TraverseTemplateName( TemplateName(NameInfo.getName().getCXXDeductionGuideTemplate()))) return false; } while (false);
    break;
  case DeclarationName::Identifier:
  case DeclarationName::ObjCZeroArgSelector:
  case DeclarationName::ObjCOneArgSelector:
  case DeclarationName::ObjCMultiArgSelector:
  case DeclarationName::CXXOperatorName:
  case DeclarationName::CXXLiteralOperatorName:
  case DeclarationName::CXXUsingDirective:
    break;
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTemplateName(TemplateName Template) {
  if (DependentTemplateName *DTN = Template.getAsDependentTemplateName())
    do { if (!getDerived().TraverseNestedNameSpecifier(DTN->getQualifier())) return false; } while (false);
  else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
    do { if (!getDerived().TraverseNestedNameSpecifier(QTN->getQualifier())) return false; } while (false);
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTemplateArgument(
    const TemplateArgument &Arg) {
  switch (Arg.getKind()) {
  case TemplateArgument::Null:
  case TemplateArgument::Declaration:
  case TemplateArgument::Integral:
  case TemplateArgument::NullPtr:
    return true;
  case TemplateArgument::Type:
    return getDerived().TraverseType(Arg.getAsType());
  case TemplateArgument::Template:
  case TemplateArgument::TemplateExpansion:
    return getDerived().TraverseTemplateName(
        Arg.getAsTemplateOrTemplatePattern());
  case TemplateArgument::Expression:
    return getDerived().TraverseStmt(Arg.getAsExpr());
  case TemplateArgument::Pack:
    return getDerived().TraverseTemplateArguments(Arg.pack_begin(),
                                                  Arg.pack_size());
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTemplateArgumentLoc(
    const TemplateArgumentLoc &ArgLoc) {
  const TemplateArgument &Arg = ArgLoc.getArgument();
  switch (Arg.getKind()) {
  case TemplateArgument::Null:
  case TemplateArgument::Declaration:
  case TemplateArgument::Integral:
  case TemplateArgument::NullPtr:
    return true;
  case TemplateArgument::Type: {
    if (TypeSourceInfo *TSI = ArgLoc.getTypeSourceInfo())
      return getDerived().TraverseTypeLoc(TSI->getTypeLoc());
    else
      return getDerived().TraverseType(Arg.getAsType());
  }
  case TemplateArgument::Template:
  case TemplateArgument::TemplateExpansion:
    if (ArgLoc.getTemplateQualifierLoc())
      do { if (!getDerived().getDerived().TraverseNestedNameSpecifierLoc( ArgLoc.getTemplateQualifierLoc())) return false; } while (false);
    return getDerived().TraverseTemplateName(
        Arg.getAsTemplateOrTemplatePattern());
  case TemplateArgument::Expression:
    return getDerived().TraverseStmt(ArgLoc.getSourceExpression());
  case TemplateArgument::Pack:
    return getDerived().TraverseTemplateArguments(Arg.pack_begin(),
                                                  Arg.pack_size());
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTemplateArguments(
    const TemplateArgument *Args, unsigned NumArgs) {
  for (unsigned I = 0; I != NumArgs; ++I) {
    do { if (!getDerived().TraverseTemplateArgument(Args[I])) return false; } while (false);
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseConstructorInitializer(
    CXXCtorInitializer *Init) {
  if (TypeSourceInfo *TInfo = Init->getTypeSourceInfo())
    do { if (!getDerived().TraverseTypeLoc(TInfo->getTypeLoc())) return false; } while (false);
  if (Init->isWritten() || getDerived().shouldVisitImplicitCode())
    do { if (!getDerived().TraverseStmt(Init->getInit())) return false; } while (false);
  return true;
}
template <typename Derived>
bool
RecursiveASTVisitor<Derived>::TraverseLambdaCapture(LambdaExpr *LE,
                                                    const LambdaCapture *C,
                                                    Expr *Init) {
  if (LE->isInitCapture(C))
    do { if (!getDerived().TraverseDecl(C->getCapturedVar())) return false; } while (false);
  else
    do { if (!getDerived().TraverseStmt(Init)) return false; } while (false);
  return true;
}
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBuiltinType(BuiltinType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBuiltinType(T)) return false; } while (false); { {}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBuiltinType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseComplexType(ComplexType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromComplexType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromComplexType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePointerType(PointerType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPointerType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getPointeeType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPointerType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBlockPointerType(BlockPointerType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBlockPointerType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getPointeeType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBlockPointerType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseLValueReferenceType(LValueReferenceType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromLValueReferenceType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getPointeeType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromLValueReferenceType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseRValueReferenceType(RValueReferenceType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromRValueReferenceType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getPointeeType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromRValueReferenceType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMemberPointerType(MemberPointerType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMemberPointerType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(QualType(T->getClass(), 0))) return false; } while (false); do { if (!getDerived().TraverseType(T->getPointeeType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMemberPointerType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAdjustedType(AdjustedType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAdjustedType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getOriginalType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAdjustedType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDecayedType(DecayedType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDecayedType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getOriginalType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDecayedType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseConstantArrayType(ConstantArrayType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConstantArrayType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false); if (T->getSizeExpr()) do { if (!getDerived().TraverseStmt(const_cast<Expr*>(T->getSizeExpr()))) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConstantArrayType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseIncompleteArrayType(IncompleteArrayType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromIncompleteArrayType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromIncompleteArrayType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseVariableArrayType(VariableArrayType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVariableArrayType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false); do { if (!getDerived().TraverseStmt(T->getSizeExpr())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVariableArrayType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentSizedArrayType(DependentSizedArrayType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentSizedArrayType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false); if (T->getSizeExpr()) do { if (!getDerived().TraverseStmt(T->getSizeExpr())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentSizedArrayType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentAddressSpaceType(DependentAddressSpaceType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentAddressSpaceType(T)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(T->getAddrSpaceExpr())) return false; } while (false); do { if (!getDerived().TraverseType(T->getPointeeType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentAddressSpaceType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentVectorType(DependentVectorType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentVectorType(T)) return false; } while (false); { { if (T->getSizeExpr()) do { if (!getDerived().TraverseStmt(T->getSizeExpr())) return false; } while (false); do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentVectorType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentSizedExtVectorType(DependentSizedExtVectorType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentSizedExtVectorType(T)) return false; } while (false); { { if (T->getSizeExpr()) do { if (!getDerived().TraverseStmt(T->getSizeExpr())) return false; } while (false); do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentSizedExtVectorType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseVectorType(VectorType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVectorType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVectorType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseExtVectorType(ExtVectorType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExtVectorType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExtVectorType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseConstantMatrixType(ConstantMatrixType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConstantMatrixType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConstantMatrixType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentSizedMatrixType(DependentSizedMatrixType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentSizedMatrixType(T)) return false; } while (false); { { if (T->getRowExpr()) do { if (!getDerived().TraverseStmt(T->getRowExpr())) return false; } while (false); if (T->getColumnExpr()) do { if (!getDerived().TraverseStmt(T->getColumnExpr())) return false; } while (false); do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentSizedMatrixType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFunctionNoProtoType(FunctionNoProtoType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFunctionNoProtoType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getReturnType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFunctionNoProtoType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFunctionProtoType(FunctionProtoType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFunctionProtoType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getReturnType())) return false; } while (false); for (const auto &A : T->param_types()) { do { if (!getDerived().TraverseType(A)) return false; } while (false); } for (const auto &E : T->exceptions()) { do { if (!getDerived().TraverseType(E)) return false; } while (false); } if (Expr *NE = T->getNoexceptExpr()) do { if (!getDerived().TraverseStmt(NE)) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFunctionProtoType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnresolvedUsingType(UnresolvedUsingType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnresolvedUsingType(T)) return false; } while (false); { {}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnresolvedUsingType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypedefType(TypedefType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypedefType(T)) return false; } while (false); { {}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypedefType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypeOfExprType(TypeOfExprType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypeOfExprType(T)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(T->getUnderlyingExpr())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypeOfExprType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypeOfType(TypeOfType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypeOfType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getUnderlyingType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypeOfType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDecltypeType(DecltypeType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDecltypeType(T)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(T->getUnderlyingExpr())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDecltypeType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnaryTransformType(UnaryTransformType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnaryTransformType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getBaseType())) return false; } while (false); do { if (!getDerived().TraverseType(T->getUnderlyingType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnaryTransformType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAutoType(AutoType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAutoType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getDeducedType())) return false; } while (false); if (T->isConstrained()) { do { if (!getDerived().TraverseDecl(T->getTypeConstraintConcept())) return false; } while (false); do { if (!getDerived().TraverseTemplateArguments(T->getArgs(), T->getNumArgs())) return false; } while (false); }}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAutoType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDeducedTemplateSpecializationType(DeducedTemplateSpecializationType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDeducedTemplateSpecializationType(T)) return false; } while (false); { { do { if (!getDerived().TraverseTemplateName(T->getTemplateName())) return false; } while (false); do { if (!getDerived().TraverseType(T->getDeducedType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDeducedTemplateSpecializationType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseRecordType(RecordType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromRecordType(T)) return false; } while (false); { {}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromRecordType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseEnumType(EnumType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromEnumType(T)) return false; } while (false); { {}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromEnumType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTemplateTypeParmType(TemplateTypeParmType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTemplateTypeParmType(T)) return false; } while (false); { {}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTemplateTypeParmType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSubstTemplateTypeParmType(SubstTemplateTypeParmType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSubstTemplateTypeParmType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getReplacementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSubstTemplateTypeParmType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSubstTemplateTypeParmPackType(SubstTemplateTypeParmPackType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSubstTemplateTypeParmPackType(T)) return false; } while (false); { { do { if (!getDerived().TraverseTemplateArgument(T->getArgumentPack())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSubstTemplateTypeParmPackType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTemplateSpecializationType(TemplateSpecializationType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTemplateSpecializationType(T)) return false; } while (false); { { do { if (!getDerived().TraverseTemplateName(T->getTemplateName())) return false; } while (false); do { if (!getDerived().TraverseTemplateArguments(T->getArgs(), T->getNumArgs())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTemplateSpecializationType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseInjectedClassNameType(InjectedClassNameType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromInjectedClassNameType(T)) return false; } while (false); { {}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromInjectedClassNameType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAttributedType(AttributedType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAttributedType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getModifiedType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAttributedType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseParenType(ParenType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromParenType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getInnerType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromParenType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMacroQualifiedType(MacroQualifiedType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMacroQualifiedType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getUnderlyingType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMacroQualifiedType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseElaboratedType(ElaboratedType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromElaboratedType(T)) return false; } while (false); { { if (T->getQualifier()) { do { if (!getDerived().TraverseNestedNameSpecifier(T->getQualifier())) return false; } while (false); } do { if (!getDerived().TraverseType(T->getNamedType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromElaboratedType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentNameType(DependentNameType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentNameType(T)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifier(T->getQualifier())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentNameType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentTemplateSpecializationType(DependentTemplateSpecializationType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentTemplateSpecializationType(T)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifier(T->getQualifier())) return false; } while (false); do { if (!getDerived().TraverseTemplateArguments(T->getArgs(), T->getNumArgs())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentTemplateSpecializationType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePackExpansionType(PackExpansionType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPackExpansionType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getPattern())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPackExpansionType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCTypeParamType(ObjCTypeParamType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCTypeParamType(T)) return false; } while (false); { {}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCTypeParamType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCInterfaceType(ObjCInterfaceType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCInterfaceType(T)) return false; } while (false); { {}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCInterfaceType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCObjectType(ObjCObjectType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCObjectType(T)) return false; } while (false); { { if (T->getBaseType().getTypePtr() != T) do { if (!getDerived().TraverseType(T->getBaseType())) return false; } while (false); for (auto typeArg : T->getTypeArgsAsWritten()) { do { if (!getDerived().TraverseType(typeArg)) return false; } while (false); }}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCObjectType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCObjectPointerType(ObjCObjectPointerType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCObjectPointerType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getPointeeType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCObjectPointerType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAtomicType(AtomicType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAtomicType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getValueType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAtomicType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePipeType(PipeType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPipeType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPipeType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseExtIntType(ExtIntType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExtIntType(T)) return false; } while (false); { {}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExtIntType(T)) return false; } while (false); return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentExtIntType(DependentExtIntType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentExtIntType(T)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(T->getNumBitsExpr())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentExtIntType(T)) return false; } while (false); return true; }
template <typename Derived>
bool
RecursiveASTVisitor<Derived>::TraverseQualifiedTypeLoc(QualifiedTypeLoc TL) {
  return TraverseTypeLoc(TL.getUnqualifiedLoc());
}
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBuiltinTypeLoc(BuiltinTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromBuiltinTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromBuiltinType(const_cast<BuiltinType *>(TL.getTypePtr()))) return false; } while (false); } { {}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromBuiltinTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromBuiltinType(const_cast<BuiltinType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseComplexTypeLoc(ComplexTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromComplexTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromComplexType(const_cast<ComplexType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseType(TL.getTypePtr()->getElementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromComplexTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromComplexType(const_cast<ComplexType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePointerTypeLoc(PointerTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromPointerTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromPointerType(const_cast<PointerType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getPointeeLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromPointerTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromPointerType(const_cast<PointerType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBlockPointerTypeLoc(BlockPointerTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromBlockPointerTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromBlockPointerType(const_cast<BlockPointerType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getPointeeLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromBlockPointerTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromBlockPointerType(const_cast<BlockPointerType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromLValueReferenceTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromLValueReferenceType(const_cast<LValueReferenceType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getPointeeLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromLValueReferenceTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromLValueReferenceType(const_cast<LValueReferenceType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromRValueReferenceTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromRValueReferenceType(const_cast<RValueReferenceType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getPointeeLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromRValueReferenceTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromRValueReferenceType(const_cast<RValueReferenceType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMemberPointerTypeLoc(MemberPointerTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMemberPointerTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromMemberPointerType(const_cast<MemberPointerType *>(TL.getTypePtr()))) return false; } while (false); } { { if (auto *TSI = TL.getClassTInfo()) do { if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc())) return false; } while (false); else do { if (!getDerived().TraverseType(QualType(TL.getTypePtr()->getClass(), 0))) return false; } while (false); do { if (!getDerived().TraverseTypeLoc(TL.getPointeeLoc())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMemberPointerTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromMemberPointerType(const_cast<MemberPointerType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAdjustedTypeLoc(AdjustedTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAdjustedTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromAdjustedType(const_cast<AdjustedType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getOriginalLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAdjustedTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromAdjustedType(const_cast<AdjustedType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDecayedTypeLoc(DecayedTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDecayedTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDecayedType(const_cast<DecayedType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getOriginalLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDecayedTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDecayedType(const_cast<DecayedType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseArrayTypeLocHelper(ArrayTypeLoc TL) {
  do { if (!getDerived().TraverseStmt(TL.getSizeExpr())) return false; } while (false);
  return true;
}
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromConstantArrayTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromConstantArrayType(const_cast<ConstantArrayType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getElementLoc())) return false; } while (false); do { if (!getDerived().TraverseArrayTypeLocHelper(TL)) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromConstantArrayTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromConstantArrayType(const_cast<ConstantArrayType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromIncompleteArrayTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromIncompleteArrayType(const_cast<IncompleteArrayType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getElementLoc())) return false; } while (false); do { if (!getDerived().TraverseArrayTypeLocHelper(TL)) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromIncompleteArrayTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromIncompleteArrayType(const_cast<IncompleteArrayType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseVariableArrayTypeLoc(VariableArrayTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromVariableArrayTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromVariableArrayType(const_cast<VariableArrayType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getElementLoc())) return false; } while (false); do { if (!getDerived().TraverseArrayTypeLocHelper(TL)) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromVariableArrayTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromVariableArrayType(const_cast<VariableArrayType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentSizedArrayTypeLoc(DependentSizedArrayTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentSizedArrayTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentSizedArrayType(const_cast<DependentSizedArrayType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getElementLoc())) return false; } while (false); do { if (!getDerived().TraverseArrayTypeLocHelper(TL)) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentSizedArrayTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentSizedArrayType(const_cast<DependentSizedArrayType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentAddressSpaceTypeLoc(DependentAddressSpaceTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentAddressSpaceTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentAddressSpaceType(const_cast<DependentAddressSpaceType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseStmt(TL.getTypePtr()->getAddrSpaceExpr())) return false; } while (false); do { if (!getDerived().TraverseType(TL.getTypePtr()->getPointeeType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentAddressSpaceTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentAddressSpaceType(const_cast<DependentAddressSpaceType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentSizedExtVectorTypeLoc(DependentSizedExtVectorTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentSizedExtVectorTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentSizedExtVectorType(const_cast<DependentSizedExtVectorType *>(TL.getTypePtr()))) return false; } while (false); } { { if (TL.getTypePtr()->getSizeExpr()) do { if (!getDerived().TraverseStmt(TL.getTypePtr()->getSizeExpr())) return false; } while (false); do { if (!getDerived().TraverseType(TL.getTypePtr()->getElementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentSizedExtVectorTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentSizedExtVectorType(const_cast<DependentSizedExtVectorType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseVectorTypeLoc(VectorTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromVectorTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromVectorType(const_cast<VectorType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseType(TL.getTypePtr()->getElementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromVectorTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromVectorType(const_cast<VectorType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentVectorTypeLoc(DependentVectorTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentVectorTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentVectorType(const_cast<DependentVectorType *>(TL.getTypePtr()))) return false; } while (false); } { { if (TL.getTypePtr()->getSizeExpr()) do { if (!getDerived().TraverseStmt(TL.getTypePtr()->getSizeExpr())) return false; } while (false); do { if (!getDerived().TraverseType(TL.getTypePtr()->getElementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentVectorTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentVectorType(const_cast<DependentVectorType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseExtVectorTypeLoc(ExtVectorTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromExtVectorTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromExtVectorType(const_cast<ExtVectorType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseType(TL.getTypePtr()->getElementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromExtVectorTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromExtVectorType(const_cast<ExtVectorType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseConstantMatrixTypeLoc(ConstantMatrixTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromConstantMatrixTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromConstantMatrixType(const_cast<ConstantMatrixType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseStmt(TL.getAttrRowOperand())) return false; } while (false); do { if (!getDerived().TraverseStmt(TL.getAttrColumnOperand())) return false; } while (false); do { if (!getDerived().TraverseType(TL.getTypePtr()->getElementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromConstantMatrixTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromConstantMatrixType(const_cast<ConstantMatrixType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentSizedMatrixTypeLoc(DependentSizedMatrixTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentSizedMatrixTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentSizedMatrixType(const_cast<DependentSizedMatrixType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseStmt(TL.getAttrRowOperand())) return false; } while (false); do { if (!getDerived().TraverseStmt(TL.getAttrColumnOperand())) return false; } while (false); do { if (!getDerived().TraverseType(TL.getTypePtr()->getElementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentSizedMatrixTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentSizedMatrixType(const_cast<DependentSizedMatrixType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromFunctionNoProtoTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromFunctionNoProtoType(const_cast<FunctionNoProtoType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getReturnLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromFunctionNoProtoTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromFunctionNoProtoType(const_cast<FunctionNoProtoType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromFunctionProtoTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromFunctionProtoType(const_cast<FunctionProtoType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getReturnLoc())) return false; } while (false); const FunctionProtoType *T = TL.getTypePtr(); for (unsigned I = 0, E = TL.getNumParams(); I != E; ++I) { if (TL.getParam(I)) { do { if (!getDerived().TraverseDecl(TL.getParam(I))) return false; } while (false); } else if (I < T->getNumParams()) { do { if (!getDerived().TraverseType(T->getParamType(I))) return false; } while (false); } } for (const auto &E : T->exceptions()) { do { if (!getDerived().TraverseType(E)) return false; } while (false); } if (Expr *NE = T->getNoexceptExpr()) do { if (!getDerived().TraverseStmt(NE)) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromFunctionProtoTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromFunctionProtoType(const_cast<FunctionProtoType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromUnresolvedUsingTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromUnresolvedUsingType(const_cast<UnresolvedUsingType *>(TL.getTypePtr()))) return false; } while (false); } { {}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromUnresolvedUsingTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromUnresolvedUsingType(const_cast<UnresolvedUsingType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypedefTypeLoc(TypedefTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTypedefTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromTypedefType(const_cast<TypedefType *>(TL.getTypePtr()))) return false; } while (false); } { {}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTypedefTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromTypedefType(const_cast<TypedefType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTypeOfExprTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromTypeOfExprType(const_cast<TypeOfExprType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseStmt(TL.getUnderlyingExpr())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTypeOfExprTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromTypeOfExprType(const_cast<TypeOfExprType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypeOfTypeLoc(TypeOfTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTypeOfTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromTypeOfType(const_cast<TypeOfType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getUnderlyingTInfo()->getTypeLoc())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTypeOfTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromTypeOfType(const_cast<TypeOfType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDecltypeTypeLoc(DecltypeTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDecltypeTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDecltypeType(const_cast<DecltypeType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseStmt(TL.getTypePtr()->getUnderlyingExpr())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDecltypeTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDecltypeType(const_cast<DecltypeType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromUnaryTransformTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromUnaryTransformType(const_cast<UnaryTransformType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getUnderlyingTInfo()->getTypeLoc())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromUnaryTransformTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromUnaryTransformType(const_cast<UnaryTransformType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAutoTypeLoc(AutoTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAutoTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromAutoType(const_cast<AutoType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseType(TL.getTypePtr()->getDeducedType())) return false; } while (false); if (TL.isConstrained()) { do { if (!getDerived().TraverseNestedNameSpecifierLoc(TL.getNestedNameSpecifierLoc())) return false; } while (false); do { if (!getDerived().TraverseDeclarationNameInfo(TL.getConceptNameInfo())) return false; } while (false); for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) do { if (!getDerived().TraverseTemplateArgumentLoc(TL.getArgLoc(I))) return false; } while (false); }}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAutoTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromAutoType(const_cast<AutoType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDeducedTemplateSpecializationTypeLoc(DeducedTemplateSpecializationTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDeducedTemplateSpecializationTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDeducedTemplateSpecializationType(const_cast<DeducedTemplateSpecializationType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTemplateName(TL.getTypePtr()->getTemplateName())) return false; } while (false); do { if (!getDerived().TraverseType(TL.getTypePtr()->getDeducedType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDeducedTemplateSpecializationTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDeducedTemplateSpecializationType(const_cast<DeducedTemplateSpecializationType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseRecordTypeLoc(RecordTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromRecordTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromRecordType(const_cast<RecordType *>(TL.getTypePtr()))) return false; } while (false); } { {}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromRecordTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromRecordType(const_cast<RecordType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseEnumTypeLoc(EnumTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromEnumTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromEnumType(const_cast<EnumType *>(TL.getTypePtr()))) return false; } while (false); } { {}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromEnumTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromEnumType(const_cast<EnumType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTemplateTypeParmTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromTemplateTypeParmType(const_cast<TemplateTypeParmType *>(TL.getTypePtr()))) return false; } while (false); } { {}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTemplateTypeParmTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromTemplateTypeParmType(const_cast<TemplateTypeParmType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSubstTemplateTypeParmTypeLoc(SubstTemplateTypeParmTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSubstTemplateTypeParmTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromSubstTemplateTypeParmType(const_cast<SubstTemplateTypeParmType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseType(TL.getTypePtr()->getReplacementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSubstTemplateTypeParmTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromSubstTemplateTypeParmType(const_cast<SubstTemplateTypeParmType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSubstTemplateTypeParmPackTypeLoc(SubstTemplateTypeParmPackTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSubstTemplateTypeParmPackTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromSubstTemplateTypeParmPackType(const_cast<SubstTemplateTypeParmPackType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTemplateArgument(TL.getTypePtr()->getArgumentPack())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSubstTemplateTypeParmPackTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromSubstTemplateTypeParmPackType(const_cast<SubstTemplateTypeParmPackType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTemplateSpecializationTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromTemplateSpecializationType(const_cast<TemplateSpecializationType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTemplateName(TL.getTypePtr()->getTemplateName())) return false; } while (false); for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) { do { if (!getDerived().TraverseTemplateArgumentLoc(TL.getArgLoc(I))) return false; } while (false); }}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTemplateSpecializationTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromTemplateSpecializationType(const_cast<TemplateSpecializationType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromInjectedClassNameTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromInjectedClassNameType(const_cast<InjectedClassNameType *>(TL.getTypePtr()))) return false; } while (false); } { {}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromInjectedClassNameTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromInjectedClassNameType(const_cast<InjectedClassNameType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseParenTypeLoc(ParenTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromParenTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromParenType(const_cast<ParenType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getInnerLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromParenTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromParenType(const_cast<ParenType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMacroQualifiedTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromMacroQualifiedType(const_cast<MacroQualifiedType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getInnerLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMacroQualifiedTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromMacroQualifiedType(const_cast<MacroQualifiedType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAttributedTypeLoc(AttributedTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAttributedTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromAttributedType(const_cast<AttributedType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getModifiedLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAttributedTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromAttributedType(const_cast<AttributedType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseElaboratedTypeLoc(ElaboratedTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromElaboratedTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromElaboratedType(const_cast<ElaboratedType *>(TL.getTypePtr()))) return false; } while (false); } { { if (TL.getQualifierLoc()) { do { if (!getDerived().TraverseNestedNameSpecifierLoc(TL.getQualifierLoc())) return false; } while (false); } do { if (!getDerived().TraverseTypeLoc(TL.getNamedTypeLoc())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromElaboratedTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromElaboratedType(const_cast<ElaboratedType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentNameTypeLoc(DependentNameTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentNameTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentNameType(const_cast<DependentNameType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(TL.getQualifierLoc())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentNameTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentNameType(const_cast<DependentNameType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentTemplateSpecializationTypeLoc(DependentTemplateSpecializationTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentTemplateSpecializationTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentTemplateSpecializationType(const_cast<DependentTemplateSpecializationType *>(TL.getTypePtr()))) return false; } while (false); } { { if (TL.getQualifierLoc()) { do { if (!getDerived().TraverseNestedNameSpecifierLoc(TL.getQualifierLoc())) return false; } while (false); } for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) { do { if (!getDerived().TraverseTemplateArgumentLoc(TL.getArgLoc(I))) return false; } while (false); }}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentTemplateSpecializationTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentTemplateSpecializationType(const_cast<DependentTemplateSpecializationType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePackExpansionTypeLoc(PackExpansionTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromPackExpansionTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromPackExpansionType(const_cast<PackExpansionType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getPatternLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromPackExpansionTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromPackExpansionType(const_cast<PackExpansionType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCTypeParamTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromObjCTypeParamType(const_cast<ObjCTypeParamType *>(TL.getTypePtr()))) return false; } while (false); } { {}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCTypeParamTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromObjCTypeParamType(const_cast<ObjCTypeParamType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCInterfaceTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromObjCInterfaceType(const_cast<ObjCInterfaceType *>(TL.getTypePtr()))) return false; } while (false); } { {}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCInterfaceTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromObjCInterfaceType(const_cast<ObjCInterfaceType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCObjectTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromObjCObjectType(const_cast<ObjCObjectType *>(TL.getTypePtr()))) return false; } while (false); } { { if (TL.getTypePtr()->getBaseType().getTypePtr() != TL.getTypePtr()) do { if (!getDerived().TraverseTypeLoc(TL.getBaseLoc())) return false; } while (false); for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i) do { if (!getDerived().TraverseTypeLoc(TL.getTypeArgTInfo(i)->getTypeLoc())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCObjectTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromObjCObjectType(const_cast<ObjCObjectType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCObjectPointerTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromObjCObjectPointerType(const_cast<ObjCObjectPointerType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getPointeeLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCObjectPointerTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromObjCObjectPointerType(const_cast<ObjCObjectPointerType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAtomicTypeLoc(AtomicTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAtomicTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromAtomicType(const_cast<AtomicType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getValueLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAtomicTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromAtomicType(const_cast<AtomicType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePipeTypeLoc(PipeTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromPipeTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromPipeType(const_cast<PipeType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getValueLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromPipeTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromPipeType(const_cast<PipeType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseExtIntTypeLoc(ExtIntTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromExtIntTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromExtIntType(const_cast<ExtIntType *>(TL.getTypePtr()))) return false; } while (false); } { {}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromExtIntTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromExtIntType(const_cast<ExtIntType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentExtIntTypeLoc(DependentExtIntTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentExtIntTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentExtIntType(const_cast<DependentExtIntType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseStmt(TL.getTypePtr()->getNumBitsExpr())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentExtIntTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentExtIntType(const_cast<DependentExtIntType *>(TL.getTypePtr()))) return false; } while (false); } return true; }
template <typename Derived>
bool RecursiveASTVisitor<Derived>::canIgnoreChildDeclWhileTraversingDeclContext(
    const Decl *Child) {
  if (isa<BlockDecl>(Child) || isa<CapturedDecl>(Child))
    return true;
  if (const CXXRecordDecl* Cls = dyn_cast<CXXRecordDecl>(Child))
    return Cls->isLambda();
  return false;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseDeclContextHelper(DeclContext *DC) {
  if (!DC)
    return true;
  for (auto *Child : DC->decls()) {
    if (!canIgnoreChildDeclWhileTraversingDeclContext(Child))
      do { if (!getDerived().TraverseDecl(Child)) return false; } while (false);
  }
  return true;
}
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAccessSpecDecl(AccessSpecDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAccessSpecDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAccessSpecDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBlockDecl(BlockDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBlockDecl(D)) return false; } while (false); { { if (TypeSourceInfo *TInfo = D->getSignatureAsWritten()) do { if (!getDerived().TraverseTypeLoc(TInfo->getTypeLoc())) return false; } while (false); do { if (!getDerived().TraverseStmt(D->getBody())) return false; } while (false); for (const auto &I : D->captures()) { if (I.hasCopyExpr()) { do { if (!getDerived().TraverseStmt(I.getCopyExpr())) return false; } while (false); } } ShouldVisitChildren = false;}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBlockDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCapturedDecl(CapturedDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCapturedDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(D->getBody())) return false; } while (false); ShouldVisitChildren = false;}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCapturedDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseEmptyDecl(EmptyDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromEmptyDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromEmptyDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromLifetimeExtendedTemporaryDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(D->getTemporaryExpr())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromLifetimeExtendedTemporaryDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFileScopeAsmDecl(FileScopeAsmDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFileScopeAsmDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(D->getAsmString())) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFileScopeAsmDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseImportDecl(ImportDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromImportDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromImportDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFriendDecl(FriendDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFriendDecl(D)) return false; } while (false); { { if (D->getFriendType()) do { if (!getDerived().TraverseTypeLoc(D->getFriendType()->getTypeLoc())) return false; } while (false); else do { if (!getDerived().TraverseDecl(D->getFriendDecl())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFriendDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFriendTemplateDecl(FriendTemplateDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFriendTemplateDecl(D)) return false; } while (false); { { if (D->getFriendType()) do { if (!getDerived().TraverseTypeLoc(D->getFriendType()->getTypeLoc())) return false; } while (false); else do { if (!getDerived().TraverseDecl(D->getFriendDecl())) return false; } while (false); for (unsigned I = 0, E = D->getNumTemplateParameters(); I < E; ++I) { TemplateParameterList *TPL = D->getTemplateParameterList(I); for (TemplateParameterList::iterator ITPL = TPL->begin(), ETPL = TPL->end(); ITPL != ETPL; ++ITPL) { do { if (!getDerived().TraverseDecl(*ITPL)) return false; } while (false); } }}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFriendTemplateDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseClassScopeFunctionSpecializationDecl(ClassScopeFunctionSpecializationDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromClassScopeFunctionSpecializationDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseDecl(D->getSpecialization())) return false; } while (false); if (D->hasExplicitTemplateArgs()) { do { if (!getDerived().TraverseTemplateArgumentLocsHelper( D->getTemplateArgsAsWritten()->getTemplateArgs(), D->getTemplateArgsAsWritten()->NumTemplateArgs)) return false; } while (false); }}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromClassScopeFunctionSpecializationDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseLinkageSpecDecl(LinkageSpecDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromLinkageSpecDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromLinkageSpecDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseExportDecl(ExportDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExportDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExportDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCPropertyImplDecl(ObjCPropertyImplDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCPropertyImplDecl(D)) return false; } while (false); { { }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCPropertyImplDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseStaticAssertDecl(StaticAssertDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromStaticAssertDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(D->getAssertExpr())) return false; } while (false); do { if (!getDerived().TraverseStmt(D->getMessage())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromStaticAssertDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTranslationUnitDecl(TranslationUnitDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTranslationUnitDecl(D)) return false; } while (false); { { auto Scope = D->getASTContext().getTraversalScope(); bool HasLimitedScope = Scope.size() != 1 || !isa<TranslationUnitDecl>(Scope.front()); if (HasLimitedScope) { ShouldVisitChildren = false; for (auto *Child : Scope) { if (!canIgnoreChildDeclWhileTraversingDeclContext(Child)) do { if (!getDerived().TraverseDecl(Child)) return false; } while (false); } }}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTranslationUnitDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePragmaCommentDecl(PragmaCommentDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPragmaCommentDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPragmaCommentDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPragmaDetectMismatchDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPragmaDetectMismatchDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseExternCContextDecl(ExternCContextDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExternCContextDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExternCContextDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseNamespaceAliasDecl(NamespaceAliasDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromNamespaceAliasDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false); ShouldVisitChildren = false;}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromNamespaceAliasDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseLabelDecl(LabelDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromLabelDecl(D)) return false; } while (false); { { }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromLabelDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseNamespaceDecl(NamespaceDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromNamespaceDecl(D)) return false; } while (false); { { }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromNamespaceDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCCompatibleAliasDecl(D)) return false; } while (false); { { }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCCompatibleAliasDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCCategoryDecl(ObjCCategoryDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCCategoryDecl(D)) return false; } while (false); { { if (ObjCTypeParamList *typeParamList = D->getTypeParamList()) { for (auto typeParam : *typeParamList) { do { if (!getDerived().TraverseObjCTypeParamDecl(typeParam)) return false; } while (false); } }}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCCategoryDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCCategoryImplDecl(D)) return false; } while (false); { { }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCCategoryImplDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCImplementationDecl(ObjCImplementationDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCImplementationDecl(D)) return false; } while (false); { { }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCImplementationDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCInterfaceDecl(ObjCInterfaceDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCInterfaceDecl(D)) return false; } while (false); { { if (ObjCTypeParamList *typeParamList = D->getTypeParamListAsWritten()) { for (auto typeParam : *typeParamList) { do { if (!getDerived().TraverseObjCTypeParamDecl(typeParam)) return false; } while (false); } } if (TypeSourceInfo *superTInfo = D->getSuperClassTInfo()) { do { if (!getDerived().TraverseTypeLoc(superTInfo->getTypeLoc())) return false; } while (false); }}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCInterfaceDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCProtocolDecl(ObjCProtocolDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCProtocolDecl(D)) return false; } while (false); { { }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCProtocolDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCMethodDecl(ObjCMethodDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCMethodDecl(D)) return false; } while (false); { { if (D->getReturnTypeSourceInfo()) { do { if (!getDerived().TraverseTypeLoc(D->getReturnTypeSourceInfo()->getTypeLoc())) return false; } while (false); } for (ParmVarDecl *Parameter : D->parameters()) { do { if (!getDerived().TraverseDecl(Parameter)) return false; } while (false); } if (D->isThisDeclarationADefinition()) { do { if (!getDerived().TraverseStmt(D->getBody())) return false; } while (false); } ShouldVisitChildren = false;}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCMethodDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCTypeParamDecl(ObjCTypeParamDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCTypeParamDecl(D)) return false; } while (false); { { if (D->hasExplicitBound()) { do { if (!getDerived().TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc())) return false; } while (false); }}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCTypeParamDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCPropertyDecl(ObjCPropertyDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCPropertyDecl(D)) return false; } while (false); { { if (D->getTypeSourceInfo()) do { if (!getDerived().TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc())) return false; } while (false); else do { if (!getDerived().TraverseType(D->getType())) return false; } while (false); ShouldVisitChildren = false;}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCPropertyDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUsingDecl(UsingDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUsingDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false); do { if (!getDerived().TraverseDeclarationNameInfo(D->getNameInfo())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUsingDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUsingEnumDecl(UsingEnumDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUsingEnumDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUsingEnumDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUsingPackDecl(UsingPackDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUsingPackDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUsingPackDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUsingDirectiveDecl(UsingDirectiveDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUsingDirectiveDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUsingDirectiveDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUsingShadowDecl(UsingShadowDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUsingShadowDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUsingShadowDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConstructorUsingShadowDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConstructorUsingShadowDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPThreadPrivateDecl(D)) return false; } while (false); { { for (auto *I : D->varlists()) { do { if (!getDerived().TraverseStmt(I)) return false; } while (false); } }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPThreadPrivateDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOMPRequiresDecl(OMPRequiresDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPRequiresDecl(D)) return false; } while (false); { { for (auto *C : D->clauselists()) { do { if (!getDerived().TraverseOMPClause(C)) return false; } while (false); }}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPRequiresDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPDeclareReductionDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(D->getCombiner())) return false; } while (false); if (auto *Initializer = D->getInitializer()) do { if (!getDerived().TraverseStmt(Initializer)) return false; } while (false); do { if (!getDerived().TraverseType(D->getType())) return false; } while (false); return true;}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPDeclareReductionDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPDeclareMapperDecl(D)) return false; } while (false); { { for (auto *C : D->clauselists()) do { if (!getDerived().TraverseOMPClause(C)) return false; } while (false); do { if (!getDerived().TraverseType(D->getType())) return false; } while (false); return true;}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPDeclareMapperDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOMPCapturedExprDecl(OMPCapturedExprDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPCapturedExprDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseVarHelper(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPCapturedExprDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOMPAllocateDecl(OMPAllocateDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPAllocateDecl(D)) return false; } while (false); { { for (auto *I : D->varlists()) do { if (!getDerived().TraverseStmt(I)) return false; } while (false); for (auto *C : D->clauselists()) do { if (!getDerived().TraverseOMPClause(C)) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPAllocateDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTemplateParameterListHelper(
    TemplateParameterList *TPL) {
  if (TPL) {
    for (NamedDecl *D : *TPL) {
      do { if (!getDerived().TraverseDecl(D)) return false; } while (false);
    }
    if (Expr *RequiresClause = TPL->getRequiresClause()) {
      do { if (!getDerived().TraverseStmt(RequiresClause)) return false; } while (false);
    }
  }
  return true;
}
template <typename Derived>
template <typename T>
bool RecursiveASTVisitor<Derived>::TraverseDeclTemplateParameterLists(T *D) {
  for (unsigned i = 0; i < D->getNumTemplateParameterLists(); i++) {
    TemplateParameterList *TPL = D->getTemplateParameterList(i);
    TraverseTemplateParameterListHelper(TPL);
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations(
    ClassTemplateDecl *D) {
  for (auto *SD : D->specializations()) {
    for (auto *RD : SD->redecls()) {
      if (cast<CXXRecordDecl>(RD)->isInjectedClassName())
        continue;
      switch (
          cast<ClassTemplateSpecializationDecl>(RD)->getSpecializationKind()) {
      case TSK_Undeclared:
      case TSK_ImplicitInstantiation:
        do { if (!getDerived().TraverseDecl(RD)) return false; } while (false);
        break;
      case TSK_ExplicitInstantiationDeclaration:
      case TSK_ExplicitInstantiationDefinition:
      case TSK_ExplicitSpecialization:
        break;
      }
    }
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations(
    VarTemplateDecl *D) {
  for (auto *SD : D->specializations()) {
    for (auto *RD : SD->redecls()) {
      switch (
          cast<VarTemplateSpecializationDecl>(RD)->getSpecializationKind()) {
      case TSK_Undeclared:
      case TSK_ImplicitInstantiation:
        do { if (!getDerived().TraverseDecl(RD)) return false; } while (false);
        break;
      case TSK_ExplicitInstantiationDeclaration:
      case TSK_ExplicitInstantiationDefinition:
      case TSK_ExplicitSpecialization:
        break;
      }
    }
  }
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations(
    FunctionTemplateDecl *D) {
  for (auto *FD : D->specializations()) {
    for (auto *RD : FD->redecls()) {
      switch (RD->getTemplateSpecializationKind()) {
      case TSK_Undeclared:
      case TSK_ImplicitInstantiation:
        do { if (!getDerived().TraverseDecl(RD)) return false; } while (false);
        break;
      case TSK_ExplicitInstantiationDeclaration:
      case TSK_ExplicitInstantiationDefinition:
        do { if (!getDerived().TraverseDecl(RD)) return false; } while (false);
        break;
      case TSK_ExplicitSpecialization:
        break;
      }
    }
  }
  return true;
}
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseClassTemplateDecl(ClassTemplateDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromClassTemplateDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseTemplateParameterListHelper(D->getTemplateParameters())) return false; } while (false); do { if (!getDerived().TraverseDecl(D->getTemplatedDecl())) return false; } while (false); if (getDerived().shouldVisitTemplateInstantiations() && D == D->getCanonicalDecl()) do { if (!getDerived().TraverseTemplateInstantiations(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromClassTemplateDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseVarTemplateDecl(VarTemplateDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVarTemplateDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseTemplateParameterListHelper(D->getTemplateParameters())) return false; } while (false); do { if (!getDerived().TraverseDecl(D->getTemplatedDecl())) return false; } while (false); if (getDerived().shouldVisitTemplateInstantiations() && D == D->getCanonicalDecl()) do { if (!getDerived().TraverseTemplateInstantiations(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVarTemplateDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFunctionTemplateDecl(FunctionTemplateDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFunctionTemplateDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseTemplateParameterListHelper(D->getTemplateParameters())) return false; } while (false); do { if (!getDerived().TraverseDecl(D->getTemplatedDecl())) return false; } while (false); if (getDerived().shouldVisitTemplateInstantiations() && D == D->getCanonicalDecl()) do { if (!getDerived().TraverseTemplateInstantiations(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFunctionTemplateDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTemplateTemplateParmDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseDecl(D->getTemplatedDecl())) return false; } while (false); if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) do { if (!getDerived().TraverseTemplateArgumentLoc(D->getDefaultArgument())) return false; } while (false); do { if (!getDerived().TraverseTemplateParameterListHelper(D->getTemplateParameters())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTemplateTemplateParmDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBuiltinTemplateDecl(BuiltinTemplateDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBuiltinTemplateDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseTemplateParameterListHelper(D->getTemplateParameters())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBuiltinTemplateDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTemplateTypeParamDeclConstraints(
    const TemplateTypeParmDecl *D) {
  if (const auto *TC = D->getTypeConstraint()) {
    if (Expr *IDC = TC->getImmediatelyDeclaredConstraint()) {
      do { if (!getDerived().TraverseStmt(IDC)) return false; } while (false);
    } else {
      do { if (!getDerived().TraverseConceptReference(*TC)) return false; } while (false);
    }
  }
  return true;
}
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTemplateTypeParmDecl(TemplateTypeParmDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTemplateTypeParmDecl(D)) return false; } while (false); { { if (D->getTypeForDecl()) do { if (!getDerived().TraverseType(QualType(D->getTypeForDecl(), 0))) return false; } while (false); do { if (!getDerived().TraverseTemplateTypeParamDeclConstraints(D)) return false; } while (false); if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) do { if (!getDerived().TraverseTypeLoc(D->getDefaultArgumentInfo()->getTypeLoc())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTemplateTypeParmDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypedefDecl(TypedefDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypedefDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypedefDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypeAliasDecl(TypeAliasDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypeAliasDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypeAliasDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypeAliasTemplateDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseDecl(D->getTemplatedDecl())) return false; } while (false); do { if (!getDerived().TraverseTemplateParameterListHelper(D->getTemplateParameters())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypeAliasTemplateDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseConceptDecl(ConceptDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConceptDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseTemplateParameterListHelper(D->getTemplateParameters())) return false; } while (false); do { if (!getDerived().TraverseStmt(D->getConstraintExpr())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConceptDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnresolvedUsingTypenameDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnresolvedUsingTypenameDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnresolvedUsingIfExistsDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnresolvedUsingIfExistsDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseEnumDecl(EnumDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromEnumDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseDeclTemplateParameterLists(D)) return false; } while (false); if (D->getTypeForDecl()) do { if (!getDerived().TraverseType(QualType(D->getTypeForDecl(), 0))) return false; } while (false); do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromEnumDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseRecordHelper(RecordDecl *D) {
  do { if (!getDerived().TraverseDeclTemplateParameterLists(D)) return false; } while (false);
  do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false);
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCXXBaseSpecifier(
    const CXXBaseSpecifier &Base) {
  do { if (!getDerived().TraverseTypeLoc(Base.getTypeSourceInfo()->getTypeLoc())) return false; } while (false);
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseCXXRecordHelper(CXXRecordDecl *D) {
  if (!TraverseRecordHelper(D))
    return false;
  if (D->isCompleteDefinition()) {
    for (const auto &I : D->bases()) {
      do { if (!getDerived().TraverseCXXBaseSpecifier(I)) return false; } while (false);
    }
  }
  return true;
}
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseRecordDecl(RecordDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromRecordDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseRecordHelper(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromRecordDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXRecordDecl(CXXRecordDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXRecordDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseCXXRecordHelper(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXRecordDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromClassTemplateSpecializationDecl(D)) return false; } while (false); { { if (TypeSourceInfo *TSI = D->getTypeAsWritten()) do { if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc())) return false; } while (false); do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false); if (!getDerived().shouldVisitTemplateInstantiations() && D->getTemplateSpecializationKind() != TSK_ExplicitSpecialization) return true; }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromClassTemplateSpecializationDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVarTemplateSpecializationDecl(D)) return false; } while (false); { { if (TypeSourceInfo *TSI = D->getTypeAsWritten()) do { if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc())) return false; } while (false); do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false); if (!getDerived().shouldVisitTemplateInstantiations() && D->getTemplateSpecializationKind() != TSK_ExplicitSpecialization) return true; }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVarTemplateSpecializationDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseTemplateArgumentLocsHelper(
    const TemplateArgumentLoc *TAL, unsigned Count) {
  for (unsigned I = 0; I < Count; ++I) {
    do { if (!getDerived().TraverseTemplateArgumentLoc(TAL[I])) return false; } while (false);
  }
  return true;
}
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseClassTemplatePartialSpecializationDecl(ClassTemplatePartialSpecializationDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromClassTemplatePartialSpecializationDecl(D)) return false; } while (false); { { if (TemplateParameterList *TPL = D->getTemplateParameters()) { for (TemplateParameterList::iterator I = TPL->begin(), E = TPL->end(); I != E; ++I) { do { if (!getDerived().TraverseDecl(*I)) return false; } while (false); } } do { if (!getDerived().TraverseTemplateArgumentLocsHelper( D->getTemplateArgsAsWritten()->getTemplateArgs(), D->getTemplateArgsAsWritten()->NumTemplateArgs)) return false; } while (false); do { if (!getDerived().TraverseCXXRecordHelper(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromClassTemplatePartialSpecializationDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseVarTemplatePartialSpecializationDecl(VarTemplatePartialSpecializationDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVarTemplatePartialSpecializationDecl(D)) return false; } while (false); { { if (TemplateParameterList *TPL = D->getTemplateParameters()) { for (TemplateParameterList::iterator I = TPL->begin(), E = TPL->end(); I != E; ++I) { do { if (!getDerived().TraverseDecl(*I)) return false; } while (false); } } do { if (!getDerived().TraverseTemplateArgumentLocsHelper( D->getTemplateArgsAsWritten()->getTemplateArgs(), D->getTemplateArgsAsWritten()->NumTemplateArgs)) return false; } while (false); do { if (!getDerived().TraverseVarHelper(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVarTemplatePartialSpecializationDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseEnumConstantDecl(EnumConstantDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromEnumConstantDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(D->getInitExpr())) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromEnumConstantDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnresolvedUsingValueDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false); do { if (!getDerived().TraverseDeclarationNameInfo(D->getNameInfo())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnresolvedUsingValueDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseIndirectFieldDecl(IndirectFieldDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromIndirectFieldDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromIndirectFieldDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseDeclaratorHelper(DeclaratorDecl *D) {
  do { if (!getDerived().TraverseDeclTemplateParameterLists(D)) return false; } while (false);
  do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false);
  if (D->getTypeSourceInfo())
    do { if (!getDerived().TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc())) return false; } while (false);
  else
    do { if (!getDerived().TraverseType(D->getType())) return false; } while (false);
  return true;
}
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDecompositionDecl(DecompositionDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDecompositionDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseVarHelper(D)) return false; } while (false); for (auto *Binding : D->bindings()) { do { if (!getDerived().TraverseDecl(Binding)) return false; } while (false); }}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDecompositionDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBindingDecl(BindingDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBindingDecl(D)) return false; } while (false); { { if (getDerived().shouldVisitImplicitCode()) do { if (!getDerived().TraverseStmt(D->getBinding())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBindingDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMSPropertyDecl(MSPropertyDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMSPropertyDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseDeclaratorHelper(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMSPropertyDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMSGuidDecl(MSGuidDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMSGuidDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMSGuidDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTemplateParamObjectDecl(TemplateParamObjectDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTemplateParamObjectDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTemplateParamObjectDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFieldDecl(FieldDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFieldDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseDeclaratorHelper(D)) return false; } while (false); if (D->isBitField()) do { if (!getDerived().TraverseStmt(D->getBitWidth())) return false; } while (false); else if (D->hasInClassInitializer()) do { if (!getDerived().TraverseStmt(D->getInClassInitializer())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFieldDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCAtDefsFieldDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseDeclaratorHelper(D)) return false; } while (false); if (D->isBitField()) do { if (!getDerived().TraverseStmt(D->getBitWidth())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCAtDefsFieldDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCIvarDecl(ObjCIvarDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCIvarDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseDeclaratorHelper(D)) return false; } while (false); if (D->isBitField()) do { if (!getDerived().TraverseStmt(D->getBitWidth())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCIvarDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseFunctionHelper(FunctionDecl *D) {
  do { if (!getDerived().TraverseDeclTemplateParameterLists(D)) return false; } while (false);
  do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false);
  do { if (!getDerived().TraverseDeclarationNameInfo(D->getNameInfo())) return false; } while (false);
  if (const FunctionTemplateSpecializationInfo *FTSI =
          D->getTemplateSpecializationInfo()) {
    if (FTSI->getTemplateSpecializationKind() != TSK_Undeclared &&
        FTSI->getTemplateSpecializationKind() != TSK_ImplicitInstantiation) {
      if (const ASTTemplateArgumentListInfo *TALI =
              FTSI->TemplateArgumentsAsWritten) {
        do { if (!getDerived().TraverseTemplateArgumentLocsHelper(TALI->getTemplateArgs(), TALI->NumTemplateArgs)) return false; } while (false);
      }
    }
  }
  if (TypeSourceInfo *TSI = D->getTypeSourceInfo()) {
    do { if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc())) return false; } while (false);
  } else if (getDerived().shouldVisitImplicitCode()) {
    for (ParmVarDecl *Parameter : D->parameters()) {
      do { if (!getDerived().TraverseDecl(Parameter)) return false; } while (false);
    }
  }
  if (Expr *TrailingRequiresClause = D->getTrailingRequiresClause()) {
    do { if (!getDerived().TraverseStmt(TrailingRequiresClause)) return false; } while (false);
  }
  if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(D)) {
    for (auto *I : Ctor->inits()) {
      if (I->isWritten() || getDerived().shouldVisitImplicitCode())
        do { if (!getDerived().TraverseConstructorInitializer(I)) return false; } while (false);
    }
  }
  bool VisitBody =
      D->isThisDeclarationADefinition() &&
      (!D->isDefaulted() || getDerived().shouldVisitImplicitCode());
  if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
    if (const CXXRecordDecl *RD = MD->getParent()) {
      if (RD->isLambda() &&
          declaresSameEntity(RD->getLambdaCallOperator(), MD)) {
        VisitBody = VisitBody && getDerived().shouldVisitLambdaBody();
      }
    }
  }
  if (VisitBody) {
    do { if (!getDerived().TraverseStmt(D->getBody())) return false; } while (false);
  }
  return true;
}
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFunctionDecl(FunctionDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFunctionDecl(D)) return false; } while (false); { { ShouldVisitChildren = false; ReturnValue = TraverseFunctionHelper(D);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFunctionDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXDeductionGuideDecl(D)) return false; } while (false); { { ShouldVisitChildren = false; ReturnValue = TraverseFunctionHelper(D);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXDeductionGuideDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXMethodDecl(CXXMethodDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXMethodDecl(D)) return false; } while (false); { { ShouldVisitChildren = false; ReturnValue = TraverseFunctionHelper(D);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXMethodDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXConstructorDecl(CXXConstructorDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXConstructorDecl(D)) return false; } while (false); { { ShouldVisitChildren = false; ReturnValue = TraverseFunctionHelper(D);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXConstructorDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXConversionDecl(CXXConversionDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXConversionDecl(D)) return false; } while (false); { { ShouldVisitChildren = false; ReturnValue = TraverseFunctionHelper(D);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXConversionDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXDestructorDecl(CXXDestructorDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXDestructorDecl(D)) return false; } while (false); { { ShouldVisitChildren = false; ReturnValue = TraverseFunctionHelper(D);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXDestructorDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseVarHelper(VarDecl *D) {
  do { if (!getDerived().TraverseDeclaratorHelper(D)) return false; } while (false);
  if (!isa<ParmVarDecl>(D) &&
      (!D->isCXXForRangeDecl() || getDerived().shouldVisitImplicitCode()))
    do { if (!getDerived().TraverseStmt(D->getInit())) return false; } while (false);
  return true;
}
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseVarDecl(VarDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVarDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseVarHelper(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVarDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseImplicitParamDecl(ImplicitParamDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromImplicitParamDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseVarHelper(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromImplicitParamDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromNonTypeTemplateParmDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseDeclaratorHelper(D)) return false; } while (false); if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) do { if (!getDerived().TraverseStmt(D->getDefaultArgument())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromNonTypeTemplateParmDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseParmVarDecl(ParmVarDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromParmVarDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseVarHelper(D)) return false; } while (false); if (D->hasDefaultArg() && D->hasUninstantiatedDefaultArg() && !D->hasUnparsedDefaultArg()) do { if (!getDerived().TraverseStmt(D->getUninstantiatedDefaultArg())) return false; } while (false); if (D->hasDefaultArg() && !D->hasUninstantiatedDefaultArg() && !D->hasUnparsedDefaultArg()) do { if (!getDerived().TraverseStmt(D->getDefaultArg())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromParmVarDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseRequiresExprBodyDecl(RequiresExprBodyDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromRequiresExprBodyDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromRequiresExprBodyDecl(D)) return false; } while (false); return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseGCCAsmStmt( GCCAsmStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromGCCAsmStmt(S)) return false; } while (false); { { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getAsmString()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getAsmString())))) return false; } while (false); for (unsigned I = 0, E = S->getNumInputs(); I < E; ++I) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getInputConstraintLiteral(I)), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getInputConstraintLiteral(I))))) return false; } while (false); } for (unsigned I = 0, E = S->getNumOutputs(); I < E; ++I) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getOutputConstraintLiteral(I)), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getOutputConstraintLiteral(I))))) return false; } while (false); } for (unsigned I = 0, E = S->getNumClobbers(); I < E; ++I) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getClobberStringLiteral(I)), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getClobberStringLiteral(I))))) return false; } while (false); }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromGCCAsmStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMSAsmStmt( MSAsmStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMSAsmStmt(S)) return false; } while (false); { { }; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMSAsmStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXCatchStmt( CXXCatchStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXCatchStmt(S)) return false; } while (false); { { do { if (!getDerived().TraverseDecl(S->getExceptionDecl())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXCatchStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDeclStmt( DeclStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDeclStmt(S)) return false; } while (false); { { for (auto *I : S->decls()) { do { if (!getDerived().TraverseDecl(I)) return false; } while (false); } ShouldVisitChildren = false;}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDeclStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBreakStmt( BreakStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBreakStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromBreakStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXTryStmt( CXXTryStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXTryStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXTryStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCaseStmt( CaseStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCaseStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCaseStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCompoundStmt( CompoundStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCompoundStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCompoundStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseContinueStmt( ContinueStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromContinueStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromContinueStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDefaultStmt( DefaultStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDefaultStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDefaultStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDoStmt( DoStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDoStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDoStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseForStmt( ForStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromForStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromForStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseGotoStmt( GotoStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromGotoStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromGotoStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseIfStmt( IfStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromIfStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromIfStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseIndirectGotoStmt( IndirectGotoStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromIndirectGotoStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromIndirectGotoStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseLabelStmt( LabelStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromLabelStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromLabelStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAttributedStmt( AttributedStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAttributedStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAttributedStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseNullStmt( NullStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromNullStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromNullStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCAtCatchStmt( ObjCAtCatchStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCAtCatchStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCAtCatchStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCAtFinallyStmt( ObjCAtFinallyStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCAtFinallyStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCAtFinallyStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCAtSynchronizedStmt( ObjCAtSynchronizedStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCAtSynchronizedStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCAtSynchronizedStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCAtThrowStmt( ObjCAtThrowStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCAtThrowStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCAtThrowStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCAtTryStmt( ObjCAtTryStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCAtTryStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCAtTryStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCForCollectionStmt( ObjCForCollectionStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCForCollectionStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCForCollectionStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCAutoreleasePoolStmt( ObjCAutoreleasePoolStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCAutoreleasePoolStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCAutoreleasePoolStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXForRangeStmt( CXXForRangeStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXForRangeStmt(S)) return false; } while (false); { { if (!getDerived().shouldVisitImplicitCode()) { if (S->getInit()) do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getInit()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getInit())))) return false; } while (false); do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getLoopVarStmt()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getLoopVarStmt())))) return false; } while (false); do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getRangeInit()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getRangeInit())))) return false; } while (false); do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getBody()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getBody())))) return false; } while (false); ShouldVisitChildren = false; }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXForRangeStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMSDependentExistsStmt( MSDependentExistsStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMSDependentExistsStmt(S)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(S->getQualifierLoc())) return false; } while (false); do { if (!getDerived().TraverseDeclarationNameInfo(S->getNameInfo())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMSDependentExistsStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseReturnStmt( ReturnStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromReturnStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromReturnStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSwitchStmt( SwitchStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSwitchStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSwitchStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseWhileStmt( WhileStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromWhileStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromWhileStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseConstantExpr( ConstantExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConstantExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromConstantExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXDependentScopeMemberExpr( CXXDependentScopeMemberExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXDependentScopeMemberExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(S->getQualifierLoc())) return false; } while (false); do { if (!getDerived().TraverseDeclarationNameInfo(S->getMemberNameInfo())) return false; } while (false); if (S->hasExplicitTemplateArgs()) { do { if (!getDerived().TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(), S->getNumTemplateArgs())) return false; } while (false); }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXDependentScopeMemberExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDeclRefExpr( DeclRefExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDeclRefExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(S->getQualifierLoc())) return false; } while (false); do { if (!getDerived().TraverseDeclarationNameInfo(S->getNameInfo())) return false; } while (false); do { if (!getDerived().TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(), S->getNumTemplateArgs())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDeclRefExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentScopeDeclRefExpr( DependentScopeDeclRefExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentScopeDeclRefExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(S->getQualifierLoc())) return false; } while (false); do { if (!getDerived().TraverseDeclarationNameInfo(S->getNameInfo())) return false; } while (false); if (S->hasExplicitTemplateArgs()) { do { if (!getDerived().TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(), S->getNumTemplateArgs())) return false; } while (false); }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentScopeDeclRefExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMemberExpr( MemberExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMemberExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(S->getQualifierLoc())) return false; } while (false); do { if (!getDerived().TraverseDeclarationNameInfo(S->getMemberNameInfo())) return false; } while (false); do { if (!getDerived().TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(), S->getNumTemplateArgs())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMemberExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseImplicitCastExpr( ImplicitCastExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromImplicitCastExpr(S)) return false; } while (false); { { }; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromImplicitCastExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCStyleCastExpr( CStyleCastExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCStyleCastExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCStyleCastExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXFunctionalCastExpr( CXXFunctionalCastExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXFunctionalCastExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXFunctionalCastExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXAddrspaceCastExpr( CXXAddrspaceCastExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXAddrspaceCastExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXAddrspaceCastExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXConstCastExpr( CXXConstCastExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXConstCastExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXConstCastExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXDynamicCastExpr( CXXDynamicCastExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXDynamicCastExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXDynamicCastExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXReinterpretCastExpr( CXXReinterpretCastExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXReinterpretCastExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXReinterpretCastExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXStaticCastExpr( CXXStaticCastExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXStaticCastExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXStaticCastExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBuiltinBitCastExpr( BuiltinBitCastExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBuiltinBitCastExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromBuiltinBitCastExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseSynOrSemInitListExpr(
    InitListExpr *S, DataRecursionQueue *Queue) {
  if (S) {
    if (!getDerived().shouldTraversePostOrder())
      do { if (!getDerived().WalkUpFromInitListExpr(S)) return false; } while (false);
    for (Stmt *SubStmt : S->children()) {
      do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false);
    }
    if (!Queue && getDerived().shouldTraversePostOrder())
      do { if (!getDerived().WalkUpFromInitListExpr(S)) return false; } while (false);
  }
  return true;
}
template<typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseConceptReference(
    const ConceptReference &C) {
  do { if (!getDerived().TraverseNestedNameSpecifierLoc(C.getNestedNameSpecifierLoc())) return false; } while (false);
  do { if (!getDerived().TraverseDeclarationNameInfo(C.getConceptNameInfo())) return false; } while (false);
  if (C.hasExplicitTemplateArgs())
    do { if (!getDerived().TraverseTemplateArgumentLocsHelper( C.getTemplateArgsAsWritten()->getTemplateArgs(), C.getTemplateArgsAsWritten()->NumTemplateArgs)) return false; } while (false);
  return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseInitListExpr(
    InitListExpr *S, DataRecursionQueue *Queue) {
  if (S->isSemanticForm() && S->isSyntacticForm()) {
    do { if (!getDerived().TraverseSynOrSemInitListExpr(S, Queue)) return false; } while (false);
    return true;
  }
  do { if (!getDerived().TraverseSynOrSemInitListExpr( S->isSemanticForm() ? S->getSyntacticForm() : S, Queue)) return false; } while (false);
  if (getDerived().shouldVisitImplicitCode()) {
    do { if (!getDerived().TraverseSynOrSemInitListExpr( S->isSemanticForm() ? S : S->getSemanticForm(), Queue)) return false; } while (false);
  }
  return true;
}
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseGenericSelectionExpr( GenericSelectionExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromGenericSelectionExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(S->getControllingExpr())) return false; } while (false); for (const GenericSelectionExpr::Association Assoc : S->associations()) { if (TypeSourceInfo *TSI = Assoc.getTypeSourceInfo()) do { if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc())) return false; } while (false); do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(Assoc.getAssociationExpr()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(Assoc.getAssociationExpr())))) return false; } while (false); } ShouldVisitChildren = false;}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromGenericSelectionExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePseudoObjectExpr( PseudoObjectExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPseudoObjectExpr(S)) return false; } while (false); { { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getSyntacticForm()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getSyntacticForm())))) return false; } while (false); for (PseudoObjectExpr::semantics_iterator i = S->semantics_begin(), e = S->semantics_end(); i != e; ++i) { Expr *sub = *i; if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(sub)) sub = OVE->getSourceExpr(); do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(sub), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(sub)))) return false; } while (false); } ShouldVisitChildren = false;}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromPseudoObjectExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXScalarValueInitExpr( CXXScalarValueInitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXScalarValueInitExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXScalarValueInitExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXNewExpr( CXXNewExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXNewExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getAllocatedTypeSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXNewExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOffsetOfExpr( OffsetOfExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOffsetOfExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromOffsetOfExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnaryExprOrTypeTraitExpr( UnaryExprOrTypeTraitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnaryExprOrTypeTraitExpr(S)) return false; } while (false); { { if (S->isArgumentType()) do { if (!getDerived().TraverseTypeLoc(S->getArgumentTypeInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromUnaryExprOrTypeTraitExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXTypeidExpr( CXXTypeidExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXTypeidExpr(S)) return false; } while (false); { { if (S->isTypeOperand()) do { if (!getDerived().TraverseTypeLoc(S->getTypeOperandSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXTypeidExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMSPropertyRefExpr( MSPropertyRefExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMSPropertyRefExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(S->getQualifierLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMSPropertyRefExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMSPropertySubscriptExpr( MSPropertySubscriptExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMSPropertySubscriptExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMSPropertySubscriptExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXUuidofExpr( CXXUuidofExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXUuidofExpr(S)) return false; } while (false); { { if (S->isTypeOperand()) do { if (!getDerived().TraverseTypeLoc(S->getTypeOperandSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXUuidofExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypeTraitExpr( TypeTraitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypeTraitExpr(S)) return false; } while (false); { { for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I) do { if (!getDerived().TraverseTypeLoc(S->getArg(I)->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTypeTraitExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseArrayTypeTraitExpr( ArrayTypeTraitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromArrayTypeTraitExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getQueriedTypeSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromArrayTypeTraitExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseExpressionTraitExpr( ExpressionTraitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExpressionTraitExpr(S)) return false; } while (false); { { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getQueriedExpression()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getQueriedExpression())))) return false; } while (false); }; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromExpressionTraitExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseVAArgExpr( VAArgExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVAArgExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getWrittenTypeInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromVAArgExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXTemporaryObjectExpr( CXXTemporaryObjectExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXTemporaryObjectExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXTemporaryObjectExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseLambdaExpr( LambdaExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromLambdaExpr(S)) return false; } while (false); { { for (unsigned I = 0, N = S->capture_size(); I != N; ++I) { const LambdaCapture *C = S->capture_begin() + I; if (C->isExplicit() || getDerived().shouldVisitImplicitCode()) { do { if (!getDerived().TraverseLambdaCapture(S, C, S->capture_init_begin()[I])) return false; } while (false); } } if (getDerived().shouldVisitImplicitCode()) { do { if (!getDerived().TraverseDecl(S->getLambdaClass())) return false; } while (false); } else { TypeLoc TL = S->getCallOperator()->getTypeSourceInfo()->getTypeLoc(); FunctionProtoTypeLoc Proto = TL.getAsAdjusted<FunctionProtoTypeLoc>(); do { if (!getDerived().TraverseTemplateParameterListHelper(S->getTemplateParameterList())) return false; } while (false); if (S->hasExplicitParameters()) { for (unsigned I = 0, N = Proto.getNumParams(); I != N; ++I) do { if (!getDerived().TraverseDecl(Proto.getParam(I))) return false; } while (false); } auto *T = Proto.getTypePtr(); for (const auto &E : T->exceptions()) do { if (!getDerived().TraverseType(E)) return false; } while (false); if (Expr *NE = T->getNoexceptExpr()) do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(NE), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(NE)))) return false; } while (false); if (S->hasExplicitResultType()) do { if (!getDerived().TraverseTypeLoc(Proto.getReturnLoc())) return false; } while (false); do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getTrailingRequiresClause()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getTrailingRequiresClause())))) return false; } while (false); do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getBody()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getBody())))) return false; } while (false); } ShouldVisitChildren = false;}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromLambdaExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXUnresolvedConstructExpr( CXXUnresolvedConstructExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXUnresolvedConstructExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXUnresolvedConstructExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXConstructExpr( CXXConstructExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXConstructExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXConstructExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCallExpr( CallExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCallExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCallExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXMemberCallExpr( CXXMemberCallExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXMemberCallExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXMemberCallExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAddrLabelExpr( AddrLabelExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAddrLabelExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAddrLabelExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseArraySubscriptExpr( ArraySubscriptExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromArraySubscriptExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromArraySubscriptExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMatrixSubscriptExpr( MatrixSubscriptExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMatrixSubscriptExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMatrixSubscriptExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOMPArraySectionExpr( OMPArraySectionExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPArraySectionExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromOMPArraySectionExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOMPArrayShapingExpr( OMPArrayShapingExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPArrayShapingExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromOMPArrayShapingExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOMPIteratorExpr( OMPIteratorExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPIteratorExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromOMPIteratorExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBlockExpr( BlockExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBlockExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseDecl(S->getBlockDecl())) return false; } while (false); return true;}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromBlockExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseChooseExpr( ChooseExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromChooseExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromChooseExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCompoundLiteralExpr( CompoundLiteralExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCompoundLiteralExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCompoundLiteralExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXBindTemporaryExpr( CXXBindTemporaryExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXBindTemporaryExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXBindTemporaryExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXBoolLiteralExpr( CXXBoolLiteralExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXBoolLiteralExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXBoolLiteralExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXDefaultArgExpr( CXXDefaultArgExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXDefaultArgExpr(S)) return false; } while (false); { { if (getDerived().shouldVisitImplicitCode()) do { if (!getDerived().TraverseStmt(S->getExpr())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXDefaultArgExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXDefaultInitExpr( CXXDefaultInitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXDefaultInitExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXDefaultInitExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXDeleteExpr( CXXDeleteExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXDeleteExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXDeleteExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseExprWithCleanups( ExprWithCleanups *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExprWithCleanups(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromExprWithCleanups(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXInheritedCtorInitExpr( CXXInheritedCtorInitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXInheritedCtorInitExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXInheritedCtorInitExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXNullPtrLiteralExpr( CXXNullPtrLiteralExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXNullPtrLiteralExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXNullPtrLiteralExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXStdInitializerListExpr( CXXStdInitializerListExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXStdInitializerListExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXStdInitializerListExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXPseudoDestructorExpr( CXXPseudoDestructorExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXPseudoDestructorExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(S->getQualifierLoc())) return false; } while (false); if (TypeSourceInfo *ScopeInfo = S->getScopeTypeInfo()) do { if (!getDerived().TraverseTypeLoc(ScopeInfo->getTypeLoc())) return false; } while (false); if (TypeSourceInfo *DestroyedTypeInfo = S->getDestroyedTypeInfo()) do { if (!getDerived().TraverseTypeLoc(DestroyedTypeInfo->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXPseudoDestructorExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXThisExpr( CXXThisExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXThisExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXThisExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXThrowExpr( CXXThrowExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXThrowExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXThrowExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUserDefinedLiteral( UserDefinedLiteral *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUserDefinedLiteral(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromUserDefinedLiteral(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDesignatedInitExpr( DesignatedInitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDesignatedInitExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDesignatedInitExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDesignatedInitUpdateExpr( DesignatedInitUpdateExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDesignatedInitUpdateExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDesignatedInitUpdateExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseExtVectorElementExpr( ExtVectorElementExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExtVectorElementExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromExtVectorElementExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseGNUNullExpr( GNUNullExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromGNUNullExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromGNUNullExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseImplicitValueInitExpr( ImplicitValueInitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromImplicitValueInitExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromImplicitValueInitExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseNoInitExpr( NoInitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromNoInitExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromNoInitExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseArrayInitLoopExpr( ArrayInitLoopExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromArrayInitLoopExpr(S)) return false; } while (false); { { if (OpaqueValueExpr *OVE = S->getCommonExpr()) do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(OVE->getSourceExpr()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(OVE->getSourceExpr())))) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromArrayInitLoopExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseArrayInitIndexExpr( ArrayInitIndexExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromArrayInitIndexExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromArrayInitIndexExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCBoolLiteralExpr( ObjCBoolLiteralExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCBoolLiteralExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCBoolLiteralExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCEncodeExpr( ObjCEncodeExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCEncodeExpr(S)) return false; } while (false); { { if (TypeSourceInfo *TInfo = S->getEncodedTypeSourceInfo()) do { if (!getDerived().TraverseTypeLoc(TInfo->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCEncodeExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCIsaExpr( ObjCIsaExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCIsaExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCIsaExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCIvarRefExpr( ObjCIvarRefExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCIvarRefExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCIvarRefExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCMessageExpr( ObjCMessageExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCMessageExpr(S)) return false; } while (false); { { if (TypeSourceInfo *TInfo = S->getClassReceiverTypeInfo()) do { if (!getDerived().TraverseTypeLoc(TInfo->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCMessageExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCPropertyRefExpr( ObjCPropertyRefExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCPropertyRefExpr(S)) return false; } while (false); { { if (S->isClassReceiver()) { ObjCInterfaceDecl *IDecl = S->getClassReceiver(); QualType Type = IDecl->getASTContext().getObjCInterfaceType(IDecl); ObjCInterfaceLocInfo Data; Data.NameLoc = S->getReceiverLocation(); Data.NameEndLoc = Data.NameLoc; do { if (!getDerived().TraverseTypeLoc(TypeLoc(Type, &Data))) return false; } while (false); }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCPropertyRefExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCSubscriptRefExpr( ObjCSubscriptRefExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCSubscriptRefExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCSubscriptRefExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCProtocolExpr( ObjCProtocolExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCProtocolExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCProtocolExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCSelectorExpr( ObjCSelectorExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCSelectorExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCSelectorExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCIndirectCopyRestoreExpr( ObjCIndirectCopyRestoreExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCIndirectCopyRestoreExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCIndirectCopyRestoreExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCBridgedCastExpr( ObjCBridgedCastExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCBridgedCastExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCBridgedCastExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCAvailabilityCheckExpr( ObjCAvailabilityCheckExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCAvailabilityCheckExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCAvailabilityCheckExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseParenExpr( ParenExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromParenExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromParenExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseParenListExpr( ParenListExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromParenListExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromParenListExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSYCLUniqueStableNameExpr( SYCLUniqueStableNameExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSYCLUniqueStableNameExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSYCLUniqueStableNameExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePredefinedExpr( PredefinedExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPredefinedExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromPredefinedExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseShuffleVectorExpr( ShuffleVectorExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromShuffleVectorExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromShuffleVectorExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseConvertVectorExpr( ConvertVectorExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConvertVectorExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromConvertVectorExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseStmtExpr( StmtExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromStmtExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromStmtExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSourceLocExpr( SourceLocExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSourceLocExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSourceLocExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnresolvedLookupExpr( UnresolvedLookupExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnresolvedLookupExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(S->getQualifierLoc())) return false; } while (false); if (S->hasExplicitTemplateArgs()) { do { if (!getDerived().TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(), S->getNumTemplateArgs())) return false; } while (false); }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromUnresolvedLookupExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnresolvedMemberExpr( UnresolvedMemberExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnresolvedMemberExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(S->getQualifierLoc())) return false; } while (false); if (S->hasExplicitTemplateArgs()) { do { if (!getDerived().TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(), S->getNumTemplateArgs())) return false; } while (false); }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromUnresolvedMemberExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSEHTryStmt( SEHTryStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSEHTryStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSEHTryStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSEHExceptStmt( SEHExceptStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSEHExceptStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSEHExceptStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSEHFinallyStmt( SEHFinallyStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSEHFinallyStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSEHFinallyStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSEHLeaveStmt( SEHLeaveStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSEHLeaveStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSEHLeaveStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCapturedStmt( CapturedStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCapturedStmt(S)) return false; } while (false); { { do { if (!getDerived().TraverseDecl(S->getCapturedDecl())) return false; } while (false); }; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCapturedStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXOperatorCallExpr( CXXOperatorCallExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXOperatorCallExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXOperatorCallExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXRewrittenBinaryOperator( CXXRewrittenBinaryOperator *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXRewrittenBinaryOperator(S)) return false; } while (false); { { if (!getDerived().shouldVisitImplicitCode()) { CXXRewrittenBinaryOperator::DecomposedForm Decomposed = S->getDecomposedForm(); do { if (!getDerived().TraverseStmt(const_cast<Expr*>(Decomposed.LHS))) return false; } while (false); do { if (!getDerived().TraverseStmt(const_cast<Expr*>(Decomposed.RHS))) return false; } while (false); ShouldVisitChildren = false; }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXRewrittenBinaryOperator(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOpaqueValueExpr( OpaqueValueExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOpaqueValueExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromOpaqueValueExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypoExpr( TypoExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypoExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTypoExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseRecoveryExpr( RecoveryExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromRecoveryExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromRecoveryExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCUDAKernelCallExpr( CUDAKernelCallExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCUDAKernelCallExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCUDAKernelCallExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBinaryConditionalOperator( BinaryConditionalOperator *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBinaryConditionalOperator(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromBinaryConditionalOperator(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseConditionalOperator( ConditionalOperator *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConditionalOperator(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromConditionalOperator(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnaryOperator( UnaryOperator *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnaryOperator(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromUnaryOperator(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBinaryOperator( BinaryOperator *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBinaryOperator(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromBinaryOperator(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCompoundAssignOperator( CompoundAssignOperator *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCompoundAssignOperator(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCompoundAssignOperator(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXNoexceptExpr( CXXNoexceptExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXNoexceptExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXNoexceptExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePackExpansionExpr( PackExpansionExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPackExpansionExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromPackExpansionExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSizeOfPackExpr( SizeOfPackExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSizeOfPackExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSizeOfPackExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSubstNonTypeTemplateParmPackExpr( SubstNonTypeTemplateParmPackExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSubstNonTypeTemplateParmPackExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSubstNonTypeTemplateParmPackExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSubstNonTypeTemplateParmExpr( SubstNonTypeTemplateParmExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSubstNonTypeTemplateParmExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSubstNonTypeTemplateParmExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFunctionParmPackExpr( FunctionParmPackExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFunctionParmPackExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromFunctionParmPackExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXFoldExpr( CXXFoldExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXFoldExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXFoldExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAtomicExpr( AtomicExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAtomicExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAtomicExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMaterializeTemporaryExpr( MaterializeTemporaryExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMaterializeTemporaryExpr(S)) return false; } while (false); { { if (S->getLifetimeExtendedTemporaryDecl()) { do { if (!getDerived().TraverseLifetimeExtendedTemporaryDecl( S->getLifetimeExtendedTemporaryDecl())) return false; } while (false); ShouldVisitChildren = false; }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMaterializeTemporaryExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCoroutineBodyStmt( CoroutineBodyStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCoroutineBodyStmt(S)) return false; } while (false); { { if (!getDerived().shouldVisitImplicitCode()) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getBody()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getBody())))) return false; } while (false); ShouldVisitChildren = false; }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCoroutineBodyStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCoreturnStmt( CoreturnStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCoreturnStmt(S)) return false; } while (false); { { if (!getDerived().shouldVisitImplicitCode()) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getOperand()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getOperand())))) return false; } while (false); ShouldVisitChildren = false; }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCoreturnStmt(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCoawaitExpr( CoawaitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCoawaitExpr(S)) return false; } while (false); { { if (!getDerived().shouldVisitImplicitCode()) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getOperand()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getOperand())))) return false; } while (false); ShouldVisitChildren = false; }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCoawaitExpr(S)) return false; } while (false); } return ReturnValue; }
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentCoawaitExpr( DependentCoawaitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentCoawaitExpr(S)) return false; } while (false); { { if (!getDerived().shouldVisitImplicitCode()) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has