struct/class definitions and getAAfor calls the issue

gistfile1.txt

struct AANoUnwindImpl : AANoUnwind {
            A.getAAFor<AANoUnwind>(*this, IRPosition::callsite_function(ICS));
struct AANoUnwindFunction final : public AANoUnwindImpl {
struct AANoUnwindCallSite final : AANoUnwindImpl {
    auto &FnAA = A.getAAFor<AANoUnwind>(*this, FnPos);
class AAReturnedValuesImpl : public AAReturnedValues, public AbstractState {
    const auto &RetValAA = A.getAAFor<AAReturnedValues>(
struct AAReturnedValuesFunction final : public AAReturnedValuesImpl {
struct AAReturnedValuesCallSite final : AAReturnedValuesImpl {
struct AANoSyncImpl : AANoSync {
          A.getAAFor<AANoSync>(*this, IRPosition::callsite_function(ICS));
struct AANoSyncFunction final : public AANoSyncImpl {
struct AANoSyncCallSite final : AANoSyncImpl {
    auto &FnAA = A.getAAFor<AANoSync>(*this, FnPos);
struct AANoFreeImpl : public AANoFree {
          A.getAAFor<AANoFree>(*this, IRPosition::callsite_function(ICS));
struct AANoFreeFunction final : public AANoFreeImpl {
struct AANoFreeCallSite final : AANoFreeImpl {
    auto &FnAA = A.getAAFor<AANoFree>(*this, FnPos);
    auto &DerefAA = A.getAAFor<AADereferenceable>(QueryingAA, IRP);
        A.getAAFor<AADereferenceable>(QueryingAA, IRPosition::value(*Base));
struct AANonNullImpl : AANonNull {
struct AANonNullFloating
      const auto &DerefAA = A.getAAFor<AADereferenceable>(*this, getIRPosition());
      const auto &AA = A.getAAFor<AANonNull>(*this, IRPosition::value(V));
struct AANonNullReturned final
struct AANonNullArgument final
struct AANonNullCallSiteArgument final : AANonNullFloating {
struct AANonNullCallSiteReturned final
struct AANoRecurseImpl : public AANoRecurse {
struct AANoRecurseFunction final : AANoRecurseImpl {
          A.getAAFor<AANoRecurse>(*this, IRPosition::callsite_function(ICS));
struct AANoRecurseCallSite final : AANoRecurseImpl {
    auto &FnAA = A.getAAFor<AANoRecurse>(*this, FnPos);
struct AAWillReturnImpl : public AAWillReturn {
      const auto &WillReturnAA = A.getAAFor<AAWillReturn>(*this, IPos);
      const auto &NoRecurseAA = A.getAAFor<AANoRecurse>(*this, IPos);
struct AAWillReturnFunction final : AAWillReturnImpl {
struct AAWillReturnCallSite final : AAWillReturnImpl {
    auto &FnAA = A.getAAFor<AAWillReturn>(*this, FnPos);
struct AANoAliasImpl : AANoAlias {
struct AANoAliasFloating final : AANoAliasImpl {
struct AANoAliasArgument final
    const auto &NoSyncAA = A.getAAFor<AANoSync>(
        A.getAAFor<AAMemoryBehavior>(*this, getIRPosition());
struct AANoAliasCallSiteArgument final : AANoAliasImpl {
    auto &NoAliasAA = A.getAAFor<AANoAlias>(*this, IRP);
    auto &NoCaptureAA = A.getAAFor<AANoCapture>(*this, IRP);
struct AANoAliasReturned final : AANoAliasImpl {
      const auto &NoAliasAA = A.getAAFor<AANoAlias>(*this, RVPos);
      const auto &NoCaptureAA = A.getAAFor<AANoCapture>(*this, RVPos);
struct AANoAliasCallSiteReturned final : AANoAliasImpl {
    auto &FnAA = A.getAAFor<AANoAlias>(*this, FnPos);
struct AAIsDeadValueImpl : public AAIsDead {
struct AAIsDeadFloating : public AAIsDeadValueImpl {
        const auto &CSArgIsDead = A.getAAFor<AAIsDead>(*this, CSArgPos);
        const auto &RetIsDeadAA = A.getAAFor<AAIsDead>(*this, RetPos);
struct AAIsDeadArgument : public AAIsDeadFloating {
struct AAIsDeadCallSiteArgument : public AAIsDeadValueImpl {
    auto &ArgAA = A.getAAFor<AAIsDead>(*this, ArgPos);
struct AAIsDeadReturned : public AAIsDeadValueImpl {
      const auto &RetIsDeadAA = A.getAAFor<AAIsDead>(*this, CSRetPos);
struct AAIsDeadCallSiteReturned : public AAIsDeadFloating {
struct AAIsDeadFunction : public AAIsDead {
            const auto &AANoUnw = A.getAAFor<AANoUnwind>(*this, IPos);
               "Number of basic blocks classified as partially dead");
        const auto &AANoUnw = A.getAAFor<AANoUnwind>(*this, IPos);
      const auto &NoReturnAA = A.getAAFor<AANoReturn>(*this, IPos);
struct AAIsDeadCallSite final : AAIsDeadFunction {
struct AADereferenceableImpl : AADereferenceable {
    NonNullAA = &A.getAAFor<AANonNull>(*this, getIRPosition());
struct AADereferenceableFloating
          A.getAAFor<AADereferenceable>(*this, IRPosition::value(*Base));
struct AADereferenceableReturned final
struct AADereferenceableArgument final
struct AADereferenceableCallSiteArgument final : AADereferenceableFloating {
struct AADereferenceableCallSiteReturned final
    auto &FnAA = A.getAAFor<AADereferenceable>(*this, FnPos);
struct AAAlignImpl : AAAlign {
struct AAAlignFloating : AAAlignImpl {
      const auto &AA = A.getAAFor<AAAlign>(*this, IRPosition::value(V));
struct AAAlignReturned final
struct AAAlignArgument final
struct AAAlignCallSiteArgument final : AAAlignFloating {
struct AAAlignCallSiteReturned final : AAAlignImpl {
    auto &FnAA = A.getAAFor<AAAlign>(*this, FnPos);
struct AANoReturnImpl : public AANoReturn {
    const auto &WillReturnAA = A.getAAFor<AAWillReturn>(*this, getIRPosition());
struct AANoReturnFunction final : AANoReturnImpl {
struct AANoReturnCallSite final : AANoReturnImpl {
    auto &FnAA = A.getAAFor<AANoReturn>(*this, FnPos);
/// A class to hold the state of for no-capture attributes.
struct AANoCaptureImpl : public AANoCapture {
struct AACaptureUseTracker final : public CaptureTracker {
        A.getAAFor<AADereferenceable>(NoCaptureAA, IRPosition::value(*O));
    auto &ArgNoCaptureAA = A.getAAFor<AANoCapture>(NoCaptureAA, CSArgPos);
  const auto &IsDeadAA = A.getAAFor<AAIsDead>(*this, FnPos);
  const auto &FnMemAA = A.getAAFor<AAMemoryBehavior>(*this, FnPos);
  const auto &NoUnwindAA = A.getAAFor<AANoUnwind>(*this, FnPos);
        IsVoidTy ? nullptr : &A.getAAFor<AAReturnedValues>(*this, FnPos);
struct AANoCaptureArgument final : AANoCaptureImpl {
struct AANoCaptureCallSiteArgument final : AANoCaptureImpl {
    auto &ArgAA = A.getAAFor<AANoCapture>(*this, ArgPos);
struct AANoCaptureFloating final : AANoCaptureImpl {
struct AANoCaptureReturned final : AANoCaptureImpl {
struct AANoCaptureCallSiteReturned final : AANoCaptureImpl {
struct AAValueSimplifyImpl : AAValueSimplify {
        VAA = &A.getAAFor<AAValueSimplify>(*this, IRPosition::value(V));
      auto &VAA = A.getAAFor<AAValueSimplify>(*this, IRPosition::value(*V));
struct AAValueSimplifyArgument final : AAValueSimplifyImpl {
      const auto &MemAA = A.getAAFor<AAMemoryBehavior>(*this, getIRPosition());
struct AAValueSimplifyReturned : AAValueSimplifyImpl {
struct AAValueSimplifyFloating : AAValueSimplifyImpl {
      auto &VAA = A.getAAFor<AAValueSimplify>(*this, IRPosition::value(*V));
      auto &VAA = A.getAAFor<AAValueSimplify>(*this, IRPosition::value(V));
struct AAValueSimplifyFunction : AAValueSimplifyImpl {
struct AAValueSimplifyCallSite : AAValueSimplifyFunction {
struct AAValueSimplifyCallSiteReturned : AAValueSimplifyImpl {
    auto &FnRetAA = A.getAAFor<AAValueSimplify>(*this, RetPos);
struct AAValueSimplifyCallSiteArgument : AAValueSimplifyFloating {
struct AAHeapToStackImpl : public AAHeapToStack {
            A.getAAFor<AANoFree>(*this, IRPosition::callsite_function(*CB));
        const auto &NoCaptureAA = A.getAAFor<AANoCapture>(
struct AAHeapToStackFunction final : public AAHeapToStackImpl {
struct AAPrivatizablePtrImpl : public AAPrivatizablePtr {
struct AAPrivatizablePtrArgument final : public AAPrivatizablePtrImpl {
      auto &PrivCSArgAA = A.getAAFor<AAPrivatizablePtr>(*this, ACSArgPos);
struct AAPrivatizablePtrFloating : public AAPrivatizablePtrImpl {
          A.getAAFor<AAPrivatizablePtr>(*this, IRPosition::argument(*Arg));
struct AAPrivatizablePtrCallSiteArgument final
    auto &NoCaptureAA = A.getAAFor<AANoCapture>(*this, IRP);
    auto &NoAliasAA = A.getAAFor<AANoAlias>(*this, IRP);
    const auto &MemBehaviorAA = A.getAAFor<AAMemoryBehavior>(*this, IRP);
struct AAPrivatizablePtrCallSiteReturned final
struct AAPrivatizablePtrReturned final : public AAPrivatizablePtrFloating {
struct AAMemoryBehaviorImpl : public AAMemoryBehavior {
struct AAMemoryBehaviorFloating : AAMemoryBehaviorImpl {
struct AAMemoryBehaviorArgument : AAMemoryBehaviorFloating {
struct AAMemoryBehaviorCallSiteArgument final : AAMemoryBehaviorArgument {
    auto &ArgAA = A.getAAFor<AAMemoryBehavior>(*this, ArgPos);
struct AAMemoryBehaviorCallSiteReturned final : AAMemoryBehaviorFloating {
struct AAMemoryBehaviorFunction final : public AAMemoryBehaviorImpl {
struct AAMemoryBehaviorCallSite final : AAMemoryBehaviorImpl {
    auto &FnAA = A.getAAFor<AAMemoryBehavior>(*this, FnPos);
      const auto &MemBehaviorAA = A.getAAFor<AAMemoryBehavior>(
  const auto &FnMemAA = A.getAAFor<AAMemoryBehavior>(*this, FnPos);
  const auto &ArgNoCaptureAA = A.getAAFor<AANoCapture>(*this, IRP);
  const auto &LivenessAA = A.getAAFor<AAIsDead>(
      A.getAAFor<AANoCapture>(*this, IRPosition::callsite_argument(ICS, ArgNo));
    const auto &MemBehaviorAA = A.getAAFor<AAMemoryBehavior>(*this, ArgPos);