/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* AttrDef Definitions                                                        *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

#ifdef GET_ATTRDEF_LIST
#undef GET_ATTRDEF_LIST

::mlir::acc::ClauseDefaultValueAttr,
::mlir::acc::ReductionOperatorAttr,
::mlir::acc::ParLevelAttr,
::mlir::acc::RecipeKindAttr,
::mlir::acc::DataClauseAttr,
::mlir::acc::DataClauseModifierAttr,
::mlir::acc::DeclareAttr,
::mlir::acc::DeclareActionAttr,
::mlir::acc::DeviceTypeAttr,
::mlir::acc::GangArgTypeAttr,
::mlir::acc::CombinedConstructsTypeAttr,
::mlir::acc::ConstructAttr,
::mlir::acc::VarNameAttr,
::mlir::acc::RoutineInfoAttr,
::mlir::acc::SpecializedRoutineAttr,
::mlir::acc::GPUParallelDimAttr,
::mlir::acc::GPUParallelDimsAttr

#endif // GET_ATTRDEF_LIST

#ifdef GET_ATTRDEF_CLASSES
#undef GET_ATTRDEF_CLASSES

static ::mlir::OptionalParseResult generatedAttributeParser(::mlir::AsmParser &parser, ::llvm::StringRef *mnemonic, ::mlir::Type type, ::mlir::Attribute &value) {
  return ::mlir::AsmParser::KeywordSwitch<::mlir::OptionalParseResult>(parser)
    .Case(::mlir::acc::ClauseDefaultValueAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
      value = ::mlir::acc::ClauseDefaultValueAttr::parse(parser, type);
      return ::mlir::success(!!value);
    })
    .Case(::mlir::acc::ReductionOperatorAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
      value = ::mlir::acc::ReductionOperatorAttr::parse(parser, type);
      return ::mlir::success(!!value);
    })
    .Case(::mlir::acc::ParLevelAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
      value = ::mlir::acc::ParLevelAttr::parse(parser, type);
      return ::mlir::success(!!value);
    })
    .Case(::mlir::acc::RecipeKindAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
      value = ::mlir::acc::RecipeKindAttr::parse(parser, type);
      return ::mlir::success(!!value);
    })
    .Case(::mlir::acc::DataClauseAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
      value = ::mlir::acc::DataClauseAttr::parse(parser, type);
      return ::mlir::success(!!value);
    })
    .Case(::mlir::acc::DataClauseModifierAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
      value = ::mlir::acc::DataClauseModifierAttr::parse(parser, type);
      return ::mlir::success(!!value);
    })
    .Case(::mlir::acc::DeclareAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
      value = ::mlir::acc::DeclareAttr::parse(parser, type);
      return ::mlir::success(!!value);
    })
    .Case(::mlir::acc::DeclareActionAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
      value = ::mlir::acc::DeclareActionAttr::parse(parser, type);
      return ::mlir::success(!!value);
    })
    .Case(::mlir::acc::DeviceTypeAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
      value = ::mlir::acc::DeviceTypeAttr::parse(parser, type);
      return ::mlir::success(!!value);
    })
    .Case(::mlir::acc::GangArgTypeAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
      value = ::mlir::acc::GangArgTypeAttr::parse(parser, type);
      return ::mlir::success(!!value);
    })
    .Case(::mlir::acc::CombinedConstructsTypeAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
      value = ::mlir::acc::CombinedConstructsTypeAttr::parse(parser, type);
      return ::mlir::success(!!value);
    })
    .Case(::mlir::acc::ConstructAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
      value = ::mlir::acc::ConstructAttr::parse(parser, type);
      return ::mlir::success(!!value);
    })
    .Case(::mlir::acc::VarNameAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
      value = ::mlir::acc::VarNameAttr::parse(parser, type);
      return ::mlir::success(!!value);
    })
    .Case(::mlir::acc::RoutineInfoAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
      value = ::mlir::acc::RoutineInfoAttr::parse(parser, type);
      return ::mlir::success(!!value);
    })
    .Case(::mlir::acc::SpecializedRoutineAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
      value = ::mlir::acc::SpecializedRoutineAttr::parse(parser, type);
      return ::mlir::success(!!value);
    })
    .Case(::mlir::acc::GPUParallelDimAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
      value = ::mlir::acc::GPUParallelDimAttr::parse(parser, type);
      return ::mlir::success(!!value);
    })
    .Case(::mlir::acc::GPUParallelDimsAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
      value = ::mlir::acc::GPUParallelDimsAttr::parse(parser, type);
      return ::mlir::success(!!value);
    })
    .Default([&](llvm::StringRef keyword, llvm::SMLoc) {
      *mnemonic = keyword;
      return std::nullopt;
    });
}

static ::llvm::LogicalResult generatedAttributePrinter(::mlir::Attribute def, ::mlir::AsmPrinter &printer) {
  return ::llvm::TypeSwitch<::mlir::Attribute, ::llvm::LogicalResult>(def)    .Case<::mlir::acc::ClauseDefaultValueAttr>([&](auto t) {
      printer << ::mlir::acc::ClauseDefaultValueAttr::getMnemonic();
printer << ' ';
t.print(printer);
      return ::mlir::success();
    })
    .Case<::mlir::acc::ReductionOperatorAttr>([&](auto t) {
      printer << ::mlir::acc::ReductionOperatorAttr::getMnemonic();
t.print(printer);
      return ::mlir::success();
    })
    .Case<::mlir::acc::ParLevelAttr>([&](auto t) {
      printer << ::mlir::acc::ParLevelAttr::getMnemonic();
t.print(printer);
      return ::mlir::success();
    })
    .Case<::mlir::acc::RecipeKindAttr>([&](auto t) {
      printer << ::mlir::acc::RecipeKindAttr::getMnemonic();
t.print(printer);
      return ::mlir::success();
    })
    .Case<::mlir::acc::DataClauseAttr>([&](auto t) {
      printer << ::mlir::acc::DataClauseAttr::getMnemonic();
printer << ' ';
t.print(printer);
      return ::mlir::success();
    })
    .Case<::mlir::acc::DataClauseModifierAttr>([&](auto t) {
      printer << ::mlir::acc::DataClauseModifierAttr::getMnemonic();
printer << ' ';
t.print(printer);
      return ::mlir::success();
    })
    .Case<::mlir::acc::DeclareAttr>([&](auto t) {
      printer << ::mlir::acc::DeclareAttr::getMnemonic();
t.print(printer);
      return ::mlir::success();
    })
    .Case<::mlir::acc::DeclareActionAttr>([&](auto t) {
      printer << ::mlir::acc::DeclareActionAttr::getMnemonic();
t.print(printer);
      return ::mlir::success();
    })
    .Case<::mlir::acc::DeviceTypeAttr>([&](auto t) {
      printer << ::mlir::acc::DeviceTypeAttr::getMnemonic();
t.print(printer);
      return ::mlir::success();
    })
    .Case<::mlir::acc::GangArgTypeAttr>([&](auto t) {
      printer << ::mlir::acc::GangArgTypeAttr::getMnemonic();
t.print(printer);
      return ::mlir::success();
    })
    .Case<::mlir::acc::CombinedConstructsTypeAttr>([&](auto t) {
      printer << ::mlir::acc::CombinedConstructsTypeAttr::getMnemonic();
t.print(printer);
      return ::mlir::success();
    })
    .Case<::mlir::acc::ConstructAttr>([&](auto t) {
      printer << ::mlir::acc::ConstructAttr::getMnemonic();
printer << ' ';
t.print(printer);
      return ::mlir::success();
    })
    .Case<::mlir::acc::VarNameAttr>([&](auto t) {
      printer << ::mlir::acc::VarNameAttr::getMnemonic();
t.print(printer);
      return ::mlir::success();
    })
    .Case<::mlir::acc::RoutineInfoAttr>([&](auto t) {
      printer << ::mlir::acc::RoutineInfoAttr::getMnemonic();
t.print(printer);
      return ::mlir::success();
    })
    .Case<::mlir::acc::SpecializedRoutineAttr>([&](auto t) {
      printer << ::mlir::acc::SpecializedRoutineAttr::getMnemonic();
t.print(printer);
      return ::mlir::success();
    })
    .Case<::mlir::acc::GPUParallelDimAttr>([&](auto t) {
      printer << ::mlir::acc::GPUParallelDimAttr::getMnemonic();
t.print(printer);
      return ::mlir::success();
    })
    .Case<::mlir::acc::GPUParallelDimsAttr>([&](auto t) {
      printer << ::mlir::acc::GPUParallelDimsAttr::getMnemonic();
t.print(printer);
      return ::mlir::success();
    })
    .Default([](auto) { return ::mlir::failure(); });
}

namespace mlir::acc {

namespace detail {

struct ClauseDefaultValueAttrStorage : public ::mlir::AttributeStorage {
  using KeyTy = std::tuple<::mlir::acc::ClauseDefaultValue>;
  ClauseDefaultValueAttrStorage(::mlir::acc::ClauseDefaultValue value) : value(std::move(value)) {}

  KeyTy getAsKey() const {
    return KeyTy(value);
  }

  bool operator==(const KeyTy &tblgenKey) const {
    return (value == std::get<0>(tblgenKey));
  }

  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
    return ::llvm::hash_combine(std::get<0>(tblgenKey));
  }

  static ClauseDefaultValueAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
    auto value = std::move(std::get<0>(tblgenKey));
    return new (allocator.allocate<ClauseDefaultValueAttrStorage>()) ClauseDefaultValueAttrStorage(std::move(value));
  }

  ::mlir::acc::ClauseDefaultValue value;
};

} // namespace detail
ClauseDefaultValueAttr ClauseDefaultValueAttr::get(::mlir::MLIRContext *context, ::mlir::acc::ClauseDefaultValue value) {
  return Base::get(context, std::move(value));
}

::mlir::Attribute ClauseDefaultValueAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
  ::mlir::Builder odsBuilder(odsParser.getContext());
  ::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
  (void) odsLoc;
  ::mlir::FailureOr<::mlir::acc::ClauseDefaultValue> _result_value;

  // Parse variable 'value'
  _result_value = [&]() -> ::mlir::FailureOr<::mlir::acc::ClauseDefaultValue> {
      auto loc = odsParser.getCurrentLocation();
      std::string enumKeyword;
      if (::mlir::failed(odsParser.parseKeywordOrString(&enumKeyword)))
        return ::mlir::failure();
      auto maybeEnum = ::mlir::acc::symbolizeClauseDefaultValue(enumKeyword);
      if (maybeEnum)
        return *maybeEnum;
      return {(::llvm::LogicalResult)(odsParser.emitError(loc) << "expected " << "::mlir::acc::ClauseDefaultValue" << " to be one of: " << "present" << ", " << "none")};
    }();
  if (::mlir::failed(_result_value)) {
    odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse DefaultValueAttr parameter 'value' which is to be a `::mlir::acc::ClauseDefaultValue`");
    return {};
  }
  assert(::mlir::succeeded(_result_value));
  return ClauseDefaultValueAttr::get(odsParser.getContext(),
      ::mlir::acc::ClauseDefaultValue((*_result_value)));
}

void ClauseDefaultValueAttr::print(::mlir::AsmPrinter &odsPrinter) const {
  ::mlir::Builder odsBuilder(getContext());
  odsPrinter << stringifyClauseDefaultValue(getValue());
}

::mlir::acc::ClauseDefaultValue ClauseDefaultValueAttr::getValue() const {
  return getImpl()->value;
}


} // namespace mlir::acc
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::acc::ClauseDefaultValueAttr)
namespace mlir::acc {

namespace detail {

struct ReductionOperatorAttrStorage : public ::mlir::AttributeStorage {
  using KeyTy = std::tuple<::mlir::acc::ReductionOperator>;
  ReductionOperatorAttrStorage(::mlir::acc::ReductionOperator value) : value(std::move(value)) {}

  KeyTy getAsKey() const {
    return KeyTy(value);
  }

  bool operator==(const KeyTy &tblgenKey) const {
    return (value == std::get<0>(tblgenKey));
  }

  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
    return ::llvm::hash_combine(std::get<0>(tblgenKey));
  }

  static ReductionOperatorAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
    auto value = std::move(std::get<0>(tblgenKey));
    return new (allocator.allocate<ReductionOperatorAttrStorage>()) ReductionOperatorAttrStorage(std::move(value));
  }

  ::mlir::acc::ReductionOperator value;
};

} // namespace detail
ReductionOperatorAttr ReductionOperatorAttr::get(::mlir::MLIRContext *context, ::mlir::acc::ReductionOperator value) {
  return Base::get(context, std::move(value));
}

::mlir::Attribute ReductionOperatorAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
  ::mlir::Builder odsBuilder(odsParser.getContext());
  ::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
  (void) odsLoc;
  ::mlir::FailureOr<::mlir::acc::ReductionOperator> _result_value;
  // Parse literal '<'
  if (odsParser.parseLess()) return {};

  // Parse variable 'value'
  _result_value = [&]() -> ::mlir::FailureOr<::mlir::acc::ReductionOperator> {
      auto loc = odsParser.getCurrentLocation();
      std::string enumKeyword;
      if (::mlir::failed(odsParser.parseKeywordOrString(&enumKeyword)))
        return ::mlir::failure();
      auto maybeEnum = ::mlir::acc::symbolizeReductionOperator(enumKeyword);
      if (maybeEnum)
        return *maybeEnum;
      return {(::llvm::LogicalResult)(odsParser.emitError(loc) << "expected " << "::mlir::acc::ReductionOperator" << " to be one of: " << "none" << ", " << "add" << ", " << "mul" << ", " << "max" << ", " << "min" << ", " << "iand" << ", " << "ior" << ", " << "xor" << ", " << "eqv" << ", " << "neqv" << ", " << "land" << ", " << "lor" << ", " << "maximumf" << ", " << "minimumf" << ", " << "maxnumf" << ", " << "minnumf")};
    }();
  if (::mlir::failed(_result_value)) {
    odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse OpenACC_ReductionOperatorAttr parameter 'value' which is to be a `::mlir::acc::ReductionOperator`");
    return {};
  }
  // Parse literal '>'
  if (odsParser.parseGreater()) return {};
  assert(::mlir::succeeded(_result_value));
  return ReductionOperatorAttr::get(odsParser.getContext(),
      ::mlir::acc::ReductionOperator((*_result_value)));
}

void ReductionOperatorAttr::print(::mlir::AsmPrinter &odsPrinter) const {
  ::mlir::Builder odsBuilder(getContext());
  odsPrinter << "<";
  odsPrinter << stringifyReductionOperator(getValue());
  odsPrinter << ">";
}

::mlir::acc::ReductionOperator ReductionOperatorAttr::getValue() const {
  return getImpl()->value;
}


} // namespace mlir::acc
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::acc::ReductionOperatorAttr)
namespace mlir::acc {

namespace detail {

struct ParLevelAttrStorage : public ::mlir::AttributeStorage {
  using KeyTy = std::tuple<::mlir::acc::ParLevel>;
  ParLevelAttrStorage(::mlir::acc::ParLevel value) : value(std::move(value)) {}

  KeyTy getAsKey() const {
    return KeyTy(value);
  }

  bool operator==(const KeyTy &tblgenKey) const {
    return (value == std::get<0>(tblgenKey));
  }

  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
    return ::llvm::hash_combine(std::get<0>(tblgenKey));
  }

  static ParLevelAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
    auto value = std::move(std::get<0>(tblgenKey));
    return new (allocator.allocate<ParLevelAttrStorage>()) ParLevelAttrStorage(std::move(value));
  }

  ::mlir::acc::ParLevel value;
};

} // namespace detail
ParLevelAttr ParLevelAttr::get(::mlir::MLIRContext *context, ::mlir::acc::ParLevel value) {
  return Base::get(context, std::move(value));
}

::mlir::Attribute ParLevelAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
  ::mlir::Builder odsBuilder(odsParser.getContext());
  ::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
  (void) odsLoc;
  ::mlir::FailureOr<::mlir::acc::ParLevel> _result_value;
  // Parse literal '<'
  if (odsParser.parseLess()) return {};

  // Parse variable 'value'
  _result_value = [&]() -> ::mlir::FailureOr<::mlir::acc::ParLevel> {
      auto loc = odsParser.getCurrentLocation();
      std::string enumKeyword;
      if (::mlir::failed(odsParser.parseKeywordOrString(&enumKeyword)))
        return ::mlir::failure();
      auto maybeEnum = ::mlir::acc::symbolizeParLevel(enumKeyword);
      if (maybeEnum)
        return *maybeEnum;
      return {(::llvm::LogicalResult)(odsParser.emitError(loc) << "expected " << "::mlir::acc::ParLevel" << " to be one of: " << "seq" << ", " << "gang_dim1" << ", " << "gang_dim2" << ", " << "gang_dim3" << ", " << "worker" << ", " << "vector")};
    }();
  if (::mlir::failed(_result_value)) {
    odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse OpenACC_ParLevelAttr parameter 'value' which is to be a `::mlir::acc::ParLevel`");
    return {};
  }
  // Parse literal '>'
  if (odsParser.parseGreater()) return {};
  assert(::mlir::succeeded(_result_value));
  return ParLevelAttr::get(odsParser.getContext(),
      ::mlir::acc::ParLevel((*_result_value)));
}

void ParLevelAttr::print(::mlir::AsmPrinter &odsPrinter) const {
  ::mlir::Builder odsBuilder(getContext());
  odsPrinter << "<";
  odsPrinter << stringifyParLevel(getValue());
  odsPrinter << ">";
}

::mlir::acc::ParLevel ParLevelAttr::getValue() const {
  return getImpl()->value;
}


} // namespace mlir::acc
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::acc::ParLevelAttr)
namespace mlir::acc {

namespace detail {

struct RecipeKindAttrStorage : public ::mlir::AttributeStorage {
  using KeyTy = std::tuple<::mlir::acc::RecipeKind>;
  RecipeKindAttrStorage(::mlir::acc::RecipeKind value) : value(std::move(value)) {}

  KeyTy getAsKey() const {
    return KeyTy(value);
  }

  bool operator==(const KeyTy &tblgenKey) const {
    return (value == std::get<0>(tblgenKey));
  }

  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
    return ::llvm::hash_combine(std::get<0>(tblgenKey));
  }

  static RecipeKindAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
    auto value = std::move(std::get<0>(tblgenKey));
    return new (allocator.allocate<RecipeKindAttrStorage>()) RecipeKindAttrStorage(std::move(value));
  }

  ::mlir::acc::RecipeKind value;
};

} // namespace detail
RecipeKindAttr RecipeKindAttr::get(::mlir::MLIRContext *context, ::mlir::acc::RecipeKind value) {
  return Base::get(context, std::move(value));
}

::mlir::Attribute RecipeKindAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
  ::mlir::Builder odsBuilder(odsParser.getContext());
  ::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
  (void) odsLoc;
  ::mlir::FailureOr<::mlir::acc::RecipeKind> _result_value;
  // Parse literal '<'
  if (odsParser.parseLess()) return {};

  // Parse variable 'value'
  _result_value = [&]() -> ::mlir::FailureOr<::mlir::acc::RecipeKind> {
      auto loc = odsParser.getCurrentLocation();
      std::string enumKeyword;
      if (::mlir::failed(odsParser.parseKeywordOrString(&enumKeyword)))
        return ::mlir::failure();
      auto maybeEnum = ::mlir::acc::symbolizeRecipeKind(enumKeyword);
      if (maybeEnum)
        return *maybeEnum;
      return {(::llvm::LogicalResult)(odsParser.emitError(loc) << "expected " << "::mlir::acc::RecipeKind" << " to be one of: " << "private_recipe" << ", " << "firstprivate_recipe" << ", " << "reduction_recipe")};
    }();
  if (::mlir::failed(_result_value)) {
    odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse OpenACC_RecipeKindAttr parameter 'value' which is to be a `::mlir::acc::RecipeKind`");
    return {};
  }
  // Parse literal '>'
  if (odsParser.parseGreater()) return {};
  assert(::mlir::succeeded(_result_value));
  return RecipeKindAttr::get(odsParser.getContext(),
      ::mlir::acc::RecipeKind((*_result_value)));
}

void RecipeKindAttr::print(::mlir::AsmPrinter &odsPrinter) const {
  ::mlir::Builder odsBuilder(getContext());
  odsPrinter << "<";
  odsPrinter << stringifyRecipeKind(getValue());
  odsPrinter << ">";
}

::mlir::acc::RecipeKind RecipeKindAttr::getValue() const {
  return getImpl()->value;
}


} // namespace mlir::acc
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::acc::RecipeKindAttr)
namespace mlir::acc {

namespace detail {

struct DataClauseAttrStorage : public ::mlir::AttributeStorage {
  using KeyTy = std::tuple<::mlir::acc::DataClause>;
  DataClauseAttrStorage(::mlir::acc::DataClause value) : value(std::move(value)) {}

  KeyTy getAsKey() const {
    return KeyTy(value);
  }

  bool operator==(const KeyTy &tblgenKey) const {
    return (value == std::get<0>(tblgenKey));
  }

  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
    return ::llvm::hash_combine(std::get<0>(tblgenKey));
  }

  static DataClauseAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
    auto value = std::move(std::get<0>(tblgenKey));
    return new (allocator.allocate<DataClauseAttrStorage>()) DataClauseAttrStorage(std::move(value));
  }

  ::mlir::acc::DataClause value;
};

} // namespace detail
DataClauseAttr DataClauseAttr::get(::mlir::MLIRContext *context, ::mlir::acc::DataClause value) {
  return Base::get(context, std::move(value));
}

::mlir::Attribute DataClauseAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
  ::mlir::Builder odsBuilder(odsParser.getContext());
  ::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
  (void) odsLoc;
  ::mlir::FailureOr<::mlir::acc::DataClause> _result_value;

  // Parse variable 'value'
  _result_value = [&]() -> ::mlir::FailureOr<::mlir::acc::DataClause> {
      auto loc = odsParser.getCurrentLocation();
      std::string enumKeyword;
      if (::mlir::failed(odsParser.parseKeywordOrString(&enumKeyword)))
        return ::mlir::failure();
      auto maybeEnum = ::mlir::acc::symbolizeDataClause(enumKeyword);
      if (maybeEnum)
        return *maybeEnum;
      return {(::llvm::LogicalResult)(odsParser.emitError(loc) << "expected " << "::mlir::acc::DataClause" << " to be one of: " << "acc_copyin" << ", " << "acc_copyin_readonly" << ", " << "acc_copy" << ", " << "acc_copyout" << ", " << "acc_copyout_zero" << ", " << "acc_present" << ", " << "acc_create" << ", " << "acc_create_zero" << ", " << "acc_delete" << ", " << "acc_attach" << ", " << "acc_detach" << ", " << "acc_no_create" << ", " << "acc_private" << ", " << "acc_firstprivate" << ", " << "acc_deviceptr" << ", " << "acc_getdeviceptr" << ", " << "acc_update_host" << ", " << "acc_update_self" << ", " << "acc_update_device" << ", " << "acc_use_device" << ", " << "acc_reduction" << ", " << "acc_declare_device_resident" << ", " << "acc_declare_link" << ", " << "acc_cache" << ", " << "acc_cache_readonly")};
    }();
  if (::mlir::failed(_result_value)) {
    odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse OpenACC_DataClauseAttr parameter 'value' which is to be a `::mlir::acc::DataClause`");
    return {};
  }
  assert(::mlir::succeeded(_result_value));
  return DataClauseAttr::get(odsParser.getContext(),
      ::mlir::acc::DataClause((*_result_value)));
}

void DataClauseAttr::print(::mlir::AsmPrinter &odsPrinter) const {
  ::mlir::Builder odsBuilder(getContext());
  odsPrinter << stringifyDataClause(getValue());
}

::mlir::acc::DataClause DataClauseAttr::getValue() const {
  return getImpl()->value;
}


} // namespace mlir::acc
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::acc::DataClauseAttr)
namespace mlir::acc {

namespace detail {

struct DataClauseModifierAttrStorage : public ::mlir::AttributeStorage {
  using KeyTy = std::tuple<::mlir::acc::DataClauseModifier>;
  DataClauseModifierAttrStorage(::mlir::acc::DataClauseModifier value) : value(std::move(value)) {}

  KeyTy getAsKey() const {
    return KeyTy(value);
  }

  bool operator==(const KeyTy &tblgenKey) const {
    return (value == std::get<0>(tblgenKey));
  }

  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
    return ::llvm::hash_combine(std::get<0>(tblgenKey));
  }

  static DataClauseModifierAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
    auto value = std::move(std::get<0>(tblgenKey));
    return new (allocator.allocate<DataClauseModifierAttrStorage>()) DataClauseModifierAttrStorage(std::move(value));
  }

  ::mlir::acc::DataClauseModifier value;
};

} // namespace detail
DataClauseModifierAttr DataClauseModifierAttr::get(::mlir::MLIRContext *context, ::mlir::acc::DataClauseModifier value) {
  return Base::get(context, std::move(value));
}

::mlir::Attribute DataClauseModifierAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
  ::mlir::Builder odsBuilder(odsParser.getContext());
  ::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
  (void) odsLoc;
  ::mlir::FailureOr<::mlir::acc::DataClauseModifier> _result_value;

  // Parse variable 'value'
  _result_value = [&]() -> ::mlir::FailureOr<::mlir::acc::DataClauseModifier> {
      ::mlir::acc::DataClauseModifier flags = {};
      auto loc = odsParser.getCurrentLocation();
      std::string enumKeyword;
      do {
        if (::mlir::failed(odsParser.parseKeywordOrString(&enumKeyword)))
          return ::mlir::failure();
        auto maybeEnum = ::mlir::acc::symbolizeDataClauseModifier(enumKeyword);
        if (!maybeEnum) {
            return {(::llvm::LogicalResult)(odsParser.emitError(loc) << "expected " << "::mlir::acc::DataClauseModifier" << " to be one of: " << "none" << ", " << "zero" << ", " << "readonly" << ", " << "alwaysin" << ", " << "alwaysout" << ", " << "always" << ", " << "capture")};
        }
        flags = flags | *maybeEnum;
      } while(::mlir::succeeded(odsParser.parseOptionalComma()));
      return flags;
    }();
  if (::mlir::failed(_result_value)) {
    odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse OpenACC_DataClauseModifierAttr parameter 'value' which is to be a `::mlir::acc::DataClauseModifier`");
    return {};
  }
  assert(::mlir::succeeded(_result_value));
  return DataClauseModifierAttr::get(odsParser.getContext(),
      ::mlir::acc::DataClauseModifier((*_result_value)));
}

void DataClauseModifierAttr::print(::mlir::AsmPrinter &odsPrinter) const {
  ::mlir::Builder odsBuilder(getContext());
  odsPrinter << stringifyDataClauseModifier(getValue());
}

::mlir::acc::DataClauseModifier DataClauseModifierAttr::getValue() const {
  return getImpl()->value;
}


} // namespace mlir::acc
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::acc::DataClauseModifierAttr)
namespace mlir::acc {

namespace detail {

struct DeclareAttrStorage : public ::mlir::AttributeStorage {
  using KeyTy = std::tuple<DataClauseAttr, bool>;
  DeclareAttrStorage(DataClauseAttr dataClause, bool implicit) : dataClause(std::move(dataClause)), implicit(std::move(implicit)) {}

  KeyTy getAsKey() const {
    return KeyTy(dataClause, implicit);
  }

  bool operator==(const KeyTy &tblgenKey) const {
    return (dataClause == std::get<0>(tblgenKey)) && (implicit == std::get<1>(tblgenKey));
  }

  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
    return ::llvm::hash_combine(std::get<0>(tblgenKey), std::get<1>(tblgenKey));
  }

  static DeclareAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
    auto dataClause = std::move(std::get<0>(tblgenKey));
    auto implicit = std::move(std::get<1>(tblgenKey));
    return new (allocator.allocate<DeclareAttrStorage>()) DeclareAttrStorage(std::move(dataClause), std::move(implicit));
  }

  DataClauseAttr dataClause;
  bool implicit;
};

} // namespace detail
DeclareAttr DeclareAttr::get(::mlir::MLIRContext *context, DataClauseAttr dataClause, bool implicit) {
  return Base::get(context, std::move(dataClause), std::move(implicit));
}

DeclareAttr DeclareAttr::get(::mlir::MLIRContext *context, DataClauseAttr dataClause) {
  return Base::get(context, dataClause, /*implicit=*/false);
}

::mlir::Attribute DeclareAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
  ::mlir::Builder odsBuilder(odsParser.getContext());
  ::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
  (void) odsLoc;
  ::mlir::FailureOr<DataClauseAttr> _result_dataClause;
  ::mlir::FailureOr<bool> _result_implicit;
  // Parse literal '<'
  if (odsParser.parseLess()) return {};
  // Parse parameter struct
  bool _seen_dataClause = false;
  bool _seen_implicit = false;
  {
    const auto _loop_body = [&](::llvm::StringRef _paramKey) -> bool {
      // Parse literal '='
      if (odsParser.parseEqual()) return {};
      if (!_seen_dataClause && _paramKey == "dataClause") {
        _seen_dataClause = true;

        // Parse variable 'dataClause'
        _result_dataClause = ::mlir::FieldParser<DataClauseAttr>::parse(odsParser);
        if (::mlir::failed(_result_dataClause)) {
          odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse DeclareAttr parameter 'dataClause' which is to be a `DataClauseAttr`");
          return {};
        }
      } else if (!_seen_implicit && _paramKey == "implicit") {
        _seen_implicit = true;

        // Parse variable 'implicit'
        _result_implicit = ::mlir::FieldParser<bool>::parse(odsParser);
        if (::mlir::failed(_result_implicit)) {
          odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse DeclareAttr parameter 'implicit' which is to be a `bool`");
          return {};
        }
      } else {
        odsParser.emitError(odsParser.getCurrentLocation(), "duplicate or unknown struct parameter name: ") << _paramKey;
        return {};
      }
      return true;
    };
    do {
      ::llvm::StringRef _paramKey;
      if (odsParser.parseKeyword(&_paramKey)) {
        odsParser.emitError(odsParser.getCurrentLocation(),
                           "expected a parameter name in struct");
        return {};
      }
      if (!_loop_body(_paramKey)) return {};
    } while(!odsParser.parseOptionalComma());
    if (!_seen_dataClause) {
      odsParser.emitError(odsParser.getCurrentLocation(), "struct is missing required parameter: ") << "dataClause";
      return {};
    }
  }
  // Parse literal '>'
  if (odsParser.parseGreater()) return {};
  assert(::mlir::succeeded(_result_dataClause));
  return DeclareAttr::get(odsParser.getContext(),
      DataClauseAttr((*_result_dataClause)),
      bool((_result_implicit.value_or(false))));
}

void DeclareAttr::print(::mlir::AsmPrinter &odsPrinter) const {
  ::mlir::Builder odsBuilder(getContext());
  odsPrinter << "<";
  {
    bool _firstPrinted = true;
    if (!_firstPrinted) odsPrinter << ", ";
    _firstPrinted = false;
    odsPrinter << "dataClause = ";
    odsPrinter.printStrippedAttrOrType(getDataClause());
    if (!(getImplicit() == false)) {
      if (!_firstPrinted) odsPrinter << ", ";
      _firstPrinted = false;
      odsPrinter << "implicit = ";
      if (!(getImplicit() == false)) {
        odsPrinter.printStrippedAttrOrType(getImplicit());
      }
    }
  }
  odsPrinter << ">";
}

DataClauseAttr DeclareAttr::getDataClause() const {
  return getImpl()->dataClause;
}

bool DeclareAttr::getImplicit() const {
  return getImpl()->implicit;
}


} // namespace mlir::acc
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::acc::DeclareAttr)
namespace mlir::acc {

namespace detail {

struct DeclareActionAttrStorage : public ::mlir::AttributeStorage {
  using KeyTy = std::tuple<SymbolRefAttr, SymbolRefAttr, SymbolRefAttr, SymbolRefAttr>;
  DeclareActionAttrStorage(SymbolRefAttr preAlloc, SymbolRefAttr postAlloc, SymbolRefAttr preDealloc, SymbolRefAttr postDealloc) : preAlloc(std::move(preAlloc)), postAlloc(std::move(postAlloc)), preDealloc(std::move(preDealloc)), postDealloc(std::move(postDealloc)) {}

  KeyTy getAsKey() const {
    return KeyTy(preAlloc, postAlloc, preDealloc, postDealloc);
  }

  bool operator==(const KeyTy &tblgenKey) const {
    return (preAlloc == std::get<0>(tblgenKey)) && (postAlloc == std::get<1>(tblgenKey)) && (preDealloc == std::get<2>(tblgenKey)) && (postDealloc == std::get<3>(tblgenKey));
  }

  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
    return ::llvm::hash_combine(std::get<0>(tblgenKey), std::get<1>(tblgenKey), std::get<2>(tblgenKey), std::get<3>(tblgenKey));
  }

  static DeclareActionAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
    auto preAlloc = std::move(std::get<0>(tblgenKey));
    auto postAlloc = std::move(std::get<1>(tblgenKey));
    auto preDealloc = std::move(std::get<2>(tblgenKey));
    auto postDealloc = std::move(std::get<3>(tblgenKey));
    return new (allocator.allocate<DeclareActionAttrStorage>()) DeclareActionAttrStorage(std::move(preAlloc), std::move(postAlloc), std::move(preDealloc), std::move(postDealloc));
  }

  SymbolRefAttr preAlloc;
  SymbolRefAttr postAlloc;
  SymbolRefAttr preDealloc;
  SymbolRefAttr postDealloc;
};

} // namespace detail
DeclareActionAttr DeclareActionAttr::get(::mlir::MLIRContext *context, SymbolRefAttr preAlloc, SymbolRefAttr postAlloc, SymbolRefAttr preDealloc, SymbolRefAttr postDealloc) {
  return Base::get(context, std::move(preAlloc), std::move(postAlloc), std::move(preDealloc), std::move(postDealloc));
}

::mlir::Attribute DeclareActionAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
  ::mlir::Builder odsBuilder(odsParser.getContext());
  ::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
  (void) odsLoc;
  ::mlir::FailureOr<SymbolRefAttr> _result_preAlloc;
  ::mlir::FailureOr<SymbolRefAttr> _result_postAlloc;
  ::mlir::FailureOr<SymbolRefAttr> _result_preDealloc;
  ::mlir::FailureOr<SymbolRefAttr> _result_postDealloc;
  // Parse literal '<'
  if (odsParser.parseLess()) return {};
  // Parse parameter struct
  bool _seen_preAlloc = false;
  bool _seen_postAlloc = false;
  bool _seen_preDealloc = false;
  bool _seen_postDealloc = false;
  {
    const auto _loop_body = [&](::llvm::StringRef _paramKey) -> bool {
      // Parse literal '='
      if (odsParser.parseEqual()) return {};
      if (!_seen_preAlloc && _paramKey == "preAlloc") {
        _seen_preAlloc = true;

        // Parse variable 'preAlloc'
        _result_preAlloc = ::mlir::FieldParser<SymbolRefAttr>::parse(odsParser);
        if (::mlir::failed(_result_preAlloc)) {
          odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse DeclareActionAttr parameter 'preAlloc' which is to be a `SymbolRefAttr`");
          return {};
        }
      } else if (!_seen_postAlloc && _paramKey == "postAlloc") {
        _seen_postAlloc = true;

        // Parse variable 'postAlloc'
        _result_postAlloc = ::mlir::FieldParser<SymbolRefAttr>::parse(odsParser);
        if (::mlir::failed(_result_postAlloc)) {
          odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse DeclareActionAttr parameter 'postAlloc' which is to be a `SymbolRefAttr`");
          return {};
        }
      } else if (!_seen_preDealloc && _paramKey == "preDealloc") {
        _seen_preDealloc = true;

        // Parse variable 'preDealloc'
        _result_preDealloc = ::mlir::FieldParser<SymbolRefAttr>::parse(odsParser);
        if (::mlir::failed(_result_preDealloc)) {
          odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse DeclareActionAttr parameter 'preDealloc' which is to be a `SymbolRefAttr`");
          return {};
        }
      } else if (!_seen_postDealloc && _paramKey == "postDealloc") {
        _seen_postDealloc = true;

        // Parse variable 'postDealloc'
        _result_postDealloc = ::mlir::FieldParser<SymbolRefAttr>::parse(odsParser);
        if (::mlir::failed(_result_postDealloc)) {
          odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse DeclareActionAttr parameter 'postDealloc' which is to be a `SymbolRefAttr`");
          return {};
        }
      } else {
        odsParser.emitError(odsParser.getCurrentLocation(), "duplicate or unknown struct parameter name: ") << _paramKey;
        return {};
      }
      return true;
    };
    ::llvm::StringRef _paramKey;
    if (!odsParser.parseOptionalKeyword(&_paramKey)) {
      if (!_loop_body(_paramKey)) return {};
      while (!odsParser.parseOptionalComma()) {
        ::llvm::StringRef _paramKey;
        if (odsParser.parseKeyword(&_paramKey)) {
          odsParser.emitError(odsParser.getCurrentLocation(),
                             "expected a parameter name in struct");
          return {};
        }
        if (!_loop_body(_paramKey)) return {};
      }
    }
  }
  // Parse literal '>'
  if (odsParser.parseGreater()) return {};
  return DeclareActionAttr::get(odsParser.getContext(),
      SymbolRefAttr((_result_preAlloc.value_or(SymbolRefAttr()))),
      SymbolRefAttr((_result_postAlloc.value_or(SymbolRefAttr()))),
      SymbolRefAttr((_result_preDealloc.value_or(SymbolRefAttr()))),
      SymbolRefAttr((_result_postDealloc.value_or(SymbolRefAttr()))));
}

void DeclareActionAttr::print(::mlir::AsmPrinter &odsPrinter) const {
  ::mlir::Builder odsBuilder(getContext());
  odsPrinter << "<";
  {
    bool _firstPrinted = true;
    if (!(getPreAlloc() == SymbolRefAttr())) {
      if (!_firstPrinted) odsPrinter << ", ";
      _firstPrinted = false;
      odsPrinter << "preAlloc = ";
      if (!(getPreAlloc() == SymbolRefAttr())) {
        odsPrinter.printStrippedAttrOrType(getPreAlloc());
      }
    }
    if (!(getPostAlloc() == SymbolRefAttr())) {
      if (!_firstPrinted) odsPrinter << ", ";
      _firstPrinted = false;
      odsPrinter << "postAlloc = ";
      if (!(getPostAlloc() == SymbolRefAttr())) {
        odsPrinter.printStrippedAttrOrType(getPostAlloc());
      }
    }
    if (!(getPreDealloc() == SymbolRefAttr())) {
      if (!_firstPrinted) odsPrinter << ", ";
      _firstPrinted = false;
      odsPrinter << "preDealloc = ";
      if (!(getPreDealloc() == SymbolRefAttr())) {
        odsPrinter.printStrippedAttrOrType(getPreDealloc());
      }
    }
    if (!(getPostDealloc() == SymbolRefAttr())) {
      if (!_firstPrinted) odsPrinter << ", ";
      _firstPrinted = false;
      odsPrinter << "postDealloc = ";
      if (!(getPostDealloc() == SymbolRefAttr())) {
        odsPrinter.printStrippedAttrOrType(getPostDealloc());
      }
    }
  }
  odsPrinter << ">";
}

SymbolRefAttr DeclareActionAttr::getPreAlloc() const {
  return getImpl()->preAlloc;
}

SymbolRefAttr DeclareActionAttr::getPostAlloc() const {
  return getImpl()->postAlloc;
}

SymbolRefAttr DeclareActionAttr::getPreDealloc() const {
  return getImpl()->preDealloc;
}

SymbolRefAttr DeclareActionAttr::getPostDealloc() const {
  return getImpl()->postDealloc;
}


} // namespace mlir::acc
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::acc::DeclareActionAttr)
namespace mlir::acc {

namespace detail {

struct DeviceTypeAttrStorage : public ::mlir::AttributeStorage {
  using KeyTy = std::tuple<::mlir::acc::DeviceType>;
  DeviceTypeAttrStorage(::mlir::acc::DeviceType value) : value(std::move(value)) {}

  KeyTy getAsKey() const {
    return KeyTy(value);
  }

  bool operator==(const KeyTy &tblgenKey) const {
    return (value == std::get<0>(tblgenKey));
  }

  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
    return ::llvm::hash_combine(std::get<0>(tblgenKey));
  }

  static DeviceTypeAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
    auto value = std::move(std::get<0>(tblgenKey));
    return new (allocator.allocate<DeviceTypeAttrStorage>()) DeviceTypeAttrStorage(std::move(value));
  }

  ::mlir::acc::DeviceType value;
};

} // namespace detail
DeviceTypeAttr DeviceTypeAttr::get(::mlir::MLIRContext *context, ::mlir::acc::DeviceType value) {
  return Base::get(context, std::move(value));
}

::mlir::Attribute DeviceTypeAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
  ::mlir::Builder odsBuilder(odsParser.getContext());
  ::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
  (void) odsLoc;
  ::mlir::FailureOr<::mlir::acc::DeviceType> _result_value;
  // Parse literal '<'
  if (odsParser.parseLess()) return {};

  // Parse variable 'value'
  _result_value = [&]() -> ::mlir::FailureOr<::mlir::acc::DeviceType> {
      auto loc = odsParser.getCurrentLocation();
      std::string enumKeyword;
      if (::mlir::failed(odsParser.parseKeywordOrString(&enumKeyword)))
        return ::mlir::failure();
      auto maybeEnum = ::mlir::acc::symbolizeDeviceType(enumKeyword);
      if (maybeEnum)
        return *maybeEnum;
      return {(::llvm::LogicalResult)(odsParser.emitError(loc) << "expected " << "::mlir::acc::DeviceType" << " to be one of: " << "none" << ", " << "star" << ", " << "default" << ", " << "host" << ", " << "multicore" << ", " << "nvidia" << ", " << "radeon")};
    }();
  if (::mlir::failed(_result_value)) {
    odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse OpenACC_DeviceTypeAttr parameter 'value' which is to be a `::mlir::acc::DeviceType`");
    return {};
  }
  // Parse literal '>'
  if (odsParser.parseGreater()) return {};
  assert(::mlir::succeeded(_result_value));
  return DeviceTypeAttr::get(odsParser.getContext(),
      ::mlir::acc::DeviceType((*_result_value)));
}

void DeviceTypeAttr::print(::mlir::AsmPrinter &odsPrinter) const {
  ::mlir::Builder odsBuilder(getContext());
  odsPrinter << "<";
  odsPrinter << stringifyDeviceType(getValue());
  odsPrinter << ">";
}

::mlir::acc::DeviceType DeviceTypeAttr::getValue() const {
  return getImpl()->value;
}


} // namespace mlir::acc
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::acc::DeviceTypeAttr)
namespace mlir::acc {

namespace detail {

struct GangArgTypeAttrStorage : public ::mlir::AttributeStorage {
  using KeyTy = std::tuple<::mlir::acc::GangArgType>;
  GangArgTypeAttrStorage(::mlir::acc::GangArgType value) : value(std::move(value)) {}

  KeyTy getAsKey() const {
    return KeyTy(value);
  }

  bool operator==(const KeyTy &tblgenKey) const {
    return (value == std::get<0>(tblgenKey));
  }

  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
    return ::llvm::hash_combine(std::get<0>(tblgenKey));
  }

  static GangArgTypeAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
    auto value = std::move(std::get<0>(tblgenKey));
    return new (allocator.allocate<GangArgTypeAttrStorage>()) GangArgTypeAttrStorage(std::move(value));
  }

  ::mlir::acc::GangArgType value;
};

} // namespace detail
GangArgTypeAttr GangArgTypeAttr::get(::mlir::MLIRContext *context, ::mlir::acc::GangArgType value) {
  return Base::get(context, std::move(value));
}

::mlir::Attribute GangArgTypeAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
  ::mlir::Builder odsBuilder(odsParser.getContext());
  ::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
  (void) odsLoc;
  ::mlir::FailureOr<::mlir::acc::GangArgType> _result_value;
  // Parse literal '<'
  if (odsParser.parseLess()) return {};

  // Parse variable 'value'
  _result_value = [&]() -> ::mlir::FailureOr<::mlir::acc::GangArgType> {
      auto loc = odsParser.getCurrentLocation();
      std::string enumKeyword;
      if (::mlir::failed(odsParser.parseKeywordOrString(&enumKeyword)))
        return ::mlir::failure();
      auto maybeEnum = ::mlir::acc::symbolizeGangArgType(enumKeyword);
      if (maybeEnum)
        return *maybeEnum;
      return {(::llvm::LogicalResult)(odsParser.emitError(loc) << "expected " << "::mlir::acc::GangArgType" << " to be one of: " << "Num" << ", " << "Dim" << ", " << "Static")};
    }();
  if (::mlir::failed(_result_value)) {
    odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse OpenACC_GangArgTypeAttr parameter 'value' which is to be a `::mlir::acc::GangArgType`");
    return {};
  }
  // Parse literal '>'
  if (odsParser.parseGreater()) return {};
  assert(::mlir::succeeded(_result_value));
  return GangArgTypeAttr::get(odsParser.getContext(),
      ::mlir::acc::GangArgType((*_result_value)));
}

void GangArgTypeAttr::print(::mlir::AsmPrinter &odsPrinter) const {
  ::mlir::Builder odsBuilder(getContext());
  odsPrinter << "<";
  odsPrinter << stringifyGangArgType(getValue());
  odsPrinter << ">";
}

::mlir::acc::GangArgType GangArgTypeAttr::getValue() const {
  return getImpl()->value;
}


} // namespace mlir::acc
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::acc::GangArgTypeAttr)
namespace mlir::acc {

namespace detail {

struct CombinedConstructsTypeAttrStorage : public ::mlir::AttributeStorage {
  using KeyTy = std::tuple<::mlir::acc::CombinedConstructsType>;
  CombinedConstructsTypeAttrStorage(::mlir::acc::CombinedConstructsType value) : value(std::move(value)) {}

  KeyTy getAsKey() const {
    return KeyTy(value);
  }

  bool operator==(const KeyTy &tblgenKey) const {
    return (value == std::get<0>(tblgenKey));
  }

  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
    return ::llvm::hash_combine(std::get<0>(tblgenKey));
  }

  static CombinedConstructsTypeAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
    auto value = std::move(std::get<0>(tblgenKey));
    return new (allocator.allocate<CombinedConstructsTypeAttrStorage>()) CombinedConstructsTypeAttrStorage(std::move(value));
  }

  ::mlir::acc::CombinedConstructsType value;
};

} // namespace detail
CombinedConstructsTypeAttr CombinedConstructsTypeAttr::get(::mlir::MLIRContext *context, ::mlir::acc::CombinedConstructsType value) {
  return Base::get(context, std::move(value));
}

::mlir::Attribute CombinedConstructsTypeAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
  ::mlir::Builder odsBuilder(odsParser.getContext());
  ::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
  (void) odsLoc;
  ::mlir::FailureOr<::mlir::acc::CombinedConstructsType> _result_value;
  // Parse literal '<'
  if (odsParser.parseLess()) return {};

  // Parse variable 'value'
  _result_value = [&]() -> ::mlir::FailureOr<::mlir::acc::CombinedConstructsType> {
      auto loc = odsParser.getCurrentLocation();
      std::string enumKeyword;
      if (::mlir::failed(odsParser.parseKeywordOrString(&enumKeyword)))
        return ::mlir::failure();
      auto maybeEnum = ::mlir::acc::symbolizeCombinedConstructsType(enumKeyword);
      if (maybeEnum)
        return *maybeEnum;
      return {(::llvm::LogicalResult)(odsParser.emitError(loc) << "expected " << "::mlir::acc::CombinedConstructsType" << " to be one of: " << "kernels_loop" << ", " << "parallel_loop" << ", " << "serial_loop")};
    }();
  if (::mlir::failed(_result_value)) {
    odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse OpenACC_CombinedConstructsAttr parameter 'value' which is to be a `::mlir::acc::CombinedConstructsType`");
    return {};
  }
  // Parse literal '>'
  if (odsParser.parseGreater()) return {};
  assert(::mlir::succeeded(_result_value));
  return CombinedConstructsTypeAttr::get(odsParser.getContext(),
      ::mlir::acc::CombinedConstructsType((*_result_value)));
}

void CombinedConstructsTypeAttr::print(::mlir::AsmPrinter &odsPrinter) const {
  ::mlir::Builder odsBuilder(getContext());
  odsPrinter << "<";
  odsPrinter << stringifyCombinedConstructsType(getValue());
  odsPrinter << ">";
}

::mlir::acc::CombinedConstructsType CombinedConstructsTypeAttr::getValue() const {
  return getImpl()->value;
}


} // namespace mlir::acc
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::acc::CombinedConstructsTypeAttr)
namespace mlir::acc {

namespace detail {

struct ConstructAttrStorage : public ::mlir::AttributeStorage {
  using KeyTy = std::tuple<::mlir::acc::Construct>;
  ConstructAttrStorage(::mlir::acc::Construct value) : value(std::move(value)) {}

  KeyTy getAsKey() const {
    return KeyTy(value);
  }

  bool operator==(const KeyTy &tblgenKey) const {
    return (value == std::get<0>(tblgenKey));
  }

  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
    return ::llvm::hash_combine(std::get<0>(tblgenKey));
  }

  static ConstructAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
    auto value = std::move(std::get<0>(tblgenKey));
    return new (allocator.allocate<ConstructAttrStorage>()) ConstructAttrStorage(std::move(value));
  }

  ::mlir::acc::Construct value;
};

} // namespace detail
ConstructAttr ConstructAttr::get(::mlir::MLIRContext *context, ::mlir::acc::Construct value) {
  return Base::get(context, std::move(value));
}

::mlir::Attribute ConstructAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
  ::mlir::Builder odsBuilder(odsParser.getContext());
  ::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
  (void) odsLoc;
  ::mlir::FailureOr<::mlir::acc::Construct> _result_value;

  // Parse variable 'value'
  _result_value = [&]() -> ::mlir::FailureOr<::mlir::acc::Construct> {
      auto loc = odsParser.getCurrentLocation();
      std::string enumKeyword;
      if (::mlir::failed(odsParser.parseKeywordOrString(&enumKeyword)))
        return ::mlir::failure();
      auto maybeEnum = ::mlir::acc::symbolizeConstruct(enumKeyword);
      if (maybeEnum)
        return *maybeEnum;
      return {(::llvm::LogicalResult)(odsParser.emitError(loc) << "expected " << "::mlir::acc::Construct" << " to be one of: " << "acc_construct_parallel" << ", " << "acc_construct_kernels" << ", " << "acc_construct_loop" << ", " << "acc_construct_data" << ", " << "acc_construct_enter_data" << ", " << "acc_construct_exit_data" << ", " << "acc_construct_host_data" << ", " << "acc_construct_atomic" << ", " << "acc_construct_declare" << ", " << "acc_construct_init" << ", " << "acc_construct_shutdown" << ", " << "acc_construct_set" << ", " << "acc_construct_update" << ", " << "acc_construct_routine" << ", " << "acc_construct_wait" << ", " << "acc_construct_runtime_api" << ", " << "acc_construct_serial")};
    }();
  if (::mlir::failed(_result_value)) {
    odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse OpenACC_ConstructAttr parameter 'value' which is to be a `::mlir::acc::Construct`");
    return {};
  }
  assert(::mlir::succeeded(_result_value));
  return ConstructAttr::get(odsParser.getContext(),
      ::mlir::acc::Construct((*_result_value)));
}

void ConstructAttr::print(::mlir::AsmPrinter &odsPrinter) const {
  ::mlir::Builder odsBuilder(getContext());
  odsPrinter << stringifyConstruct(getValue());
}

::mlir::acc::Construct ConstructAttr::getValue() const {
  return getImpl()->value;
}


} // namespace mlir::acc
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::acc::ConstructAttr)
namespace mlir::acc {

namespace detail {

struct VarNameAttrStorage : public ::mlir::AttributeStorage {
  using KeyTy = std::tuple<::llvm::StringRef>;
  VarNameAttrStorage(::llvm::StringRef name) : name(std::move(name)) {}

  KeyTy getAsKey() const {
    return KeyTy(name);
  }

  bool operator==(const KeyTy &tblgenKey) const {
    return (name == std::get<0>(tblgenKey));
  }

  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
    return ::llvm::hash_combine(std::get<0>(tblgenKey));
  }

  static VarNameAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
    auto name = std::move(std::get<0>(tblgenKey));
    name = allocator.copyInto(name);
    return new (allocator.allocate<VarNameAttrStorage>()) VarNameAttrStorage(std::move(name));
  }

  ::llvm::StringRef name;
};

} // namespace detail
VarNameAttr VarNameAttr::get(::mlir::MLIRContext *context, ::llvm::StringRef name) {
  return Base::get(context, std::move(name));
}

::mlir::Attribute VarNameAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
  ::mlir::Builder odsBuilder(odsParser.getContext());
  ::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
  (void) odsLoc;
  ::mlir::FailureOr<std::string> _result_name;
  // Parse literal '<'
  if (odsParser.parseLess()) return {};

  // Parse variable 'name'
  _result_name = ::mlir::FieldParser<std::string>::parse(odsParser);
  if (::mlir::failed(_result_name)) {
    odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse OpenACC_VarNameAttr parameter 'name' which is to be a `::llvm::StringRef`");
    return {};
  }
  // Parse literal '>'
  if (odsParser.parseGreater()) return {};
  assert(::mlir::succeeded(_result_name));
  return VarNameAttr::get(odsParser.getContext(),
      ::llvm::StringRef((*_result_name)));
}

void VarNameAttr::print(::mlir::AsmPrinter &odsPrinter) const {
  ::mlir::Builder odsBuilder(getContext());
  odsPrinter << "<";
  odsPrinter.printString(getName());;
  odsPrinter << ">";
}

::llvm::StringRef VarNameAttr::getName() const {
  return getImpl()->name;
}


} // namespace mlir::acc
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::acc::VarNameAttr)
namespace mlir::acc {

namespace detail {

struct RoutineInfoAttrStorage : public ::mlir::AttributeStorage {
  using KeyTy = std::tuple<::llvm::ArrayRef<SymbolRefAttr>>;
  RoutineInfoAttrStorage(::llvm::ArrayRef<SymbolRefAttr> accRoutines) : accRoutines(std::move(accRoutines)) {}

  KeyTy getAsKey() const {
    return KeyTy(accRoutines);
  }

  bool operator==(const KeyTy &tblgenKey) const {
    return (accRoutines == std::get<0>(tblgenKey));
  }

  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
    return ::llvm::hash_combine(std::get<0>(tblgenKey));
  }

  static RoutineInfoAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
    auto accRoutines = std::move(std::get<0>(tblgenKey));
    accRoutines = allocator.copyInto(accRoutines);
    return new (allocator.allocate<RoutineInfoAttrStorage>()) RoutineInfoAttrStorage(std::move(accRoutines));
  }

  ::llvm::ArrayRef<SymbolRefAttr> accRoutines;
};

} // namespace detail
RoutineInfoAttr RoutineInfoAttr::get(::mlir::MLIRContext *context, ::llvm::ArrayRef<SymbolRefAttr> accRoutines) {
  return Base::get(context, std::move(accRoutines));
}

::mlir::Attribute RoutineInfoAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
  ::mlir::Builder odsBuilder(odsParser.getContext());
  ::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
  (void) odsLoc;
  ::mlir::FailureOr<::llvm::SmallVector<SymbolRefAttr>> _result_accRoutines;
  // Parse literal '<'
  if (odsParser.parseLess()) return {};
  // Parse literal '['
  if (odsParser.parseLSquare()) return {};

  // Parse variable 'accRoutines'
  _result_accRoutines = ::mlir::FieldParser<::llvm::SmallVector<SymbolRefAttr>>::parse(odsParser);
  if (::mlir::failed(_result_accRoutines)) {
    odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse RoutineInfoAttr parameter 'accRoutines' which is to be a `::llvm::ArrayRef<SymbolRefAttr>`");
    return {};
  }
  // Parse literal ']'
  if (odsParser.parseRSquare()) return {};
  // Parse literal '>'
  if (odsParser.parseGreater()) return {};
  assert(::mlir::succeeded(_result_accRoutines));
  return RoutineInfoAttr::get(odsParser.getContext(),
      ::llvm::ArrayRef<SymbolRefAttr>((*_result_accRoutines)));
}

void RoutineInfoAttr::print(::mlir::AsmPrinter &odsPrinter) const {
  ::mlir::Builder odsBuilder(getContext());
  odsPrinter << "<";
  odsPrinter << "[";
  odsPrinter.printStrippedAttrOrType(getAccRoutines());
  odsPrinter << "]";
  odsPrinter << ">";
}

::llvm::ArrayRef<SymbolRefAttr> RoutineInfoAttr::getAccRoutines() const {
  return getImpl()->accRoutines;
}


} // namespace mlir::acc
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::acc::RoutineInfoAttr)
namespace mlir::acc {

namespace detail {

struct SpecializedRoutineAttrStorage : public ::mlir::AttributeStorage {
  using KeyTy = std::tuple<SymbolRefAttr, ParLevelAttr, StringAttr>;
  SpecializedRoutineAttrStorage(SymbolRefAttr routine, ParLevelAttr level, StringAttr funcName) : routine(std::move(routine)), level(std::move(level)), funcName(std::move(funcName)) {}

  KeyTy getAsKey() const {
    return KeyTy(routine, level, funcName);
  }

  bool operator==(const KeyTy &tblgenKey) const {
    return (routine == std::get<0>(tblgenKey)) && (level == std::get<1>(tblgenKey)) && (funcName == std::get<2>(tblgenKey));
  }

  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
    return ::llvm::hash_combine(std::get<0>(tblgenKey), std::get<1>(tblgenKey), std::get<2>(tblgenKey));
  }

  static SpecializedRoutineAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
    auto routine = std::move(std::get<0>(tblgenKey));
    auto level = std::move(std::get<1>(tblgenKey));
    auto funcName = std::move(std::get<2>(tblgenKey));
    return new (allocator.allocate<SpecializedRoutineAttrStorage>()) SpecializedRoutineAttrStorage(std::move(routine), std::move(level), std::move(funcName));
  }

  SymbolRefAttr routine;
  ParLevelAttr level;
  StringAttr funcName;
};

} // namespace detail
SpecializedRoutineAttr SpecializedRoutineAttr::get(::mlir::MLIRContext *context, SymbolRefAttr routine, ParLevelAttr level, StringAttr funcName) {
  return Base::get(context, std::move(routine), std::move(level), std::move(funcName));
}

::mlir::Attribute SpecializedRoutineAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
  ::mlir::Builder odsBuilder(odsParser.getContext());
  ::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
  (void) odsLoc;
  ::mlir::FailureOr<SymbolRefAttr> _result_routine;
  ::mlir::FailureOr<ParLevelAttr> _result_level;
  ::mlir::FailureOr<StringAttr> _result_funcName;
  // Parse literal '<'
  if (odsParser.parseLess()) return {};

  // Parse variable 'routine'
  _result_routine = ::mlir::FieldParser<SymbolRefAttr>::parse(odsParser);
  if (::mlir::failed(_result_routine)) {
    odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse SpecializedRoutineAttr parameter 'routine' which is to be a `SymbolRefAttr`");
    return {};
  }
  // Parse literal ','
  if (odsParser.parseComma()) return {};

  // Parse variable 'level'
  _result_level = ::mlir::FieldParser<ParLevelAttr>::parse(odsParser);
  if (::mlir::failed(_result_level)) {
    odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse SpecializedRoutineAttr parameter 'level' which is to be a `ParLevelAttr`");
    return {};
  }
  // Parse literal ','
  if (odsParser.parseComma()) return {};

  // Parse variable 'funcName'
  _result_funcName = ::mlir::FieldParser<StringAttr>::parse(odsParser);
  if (::mlir::failed(_result_funcName)) {
    odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse SpecializedRoutineAttr parameter 'funcName' which is to be a `StringAttr`");
    return {};
  }
  // Parse literal '>'
  if (odsParser.parseGreater()) return {};
  assert(::mlir::succeeded(_result_routine));
  assert(::mlir::succeeded(_result_level));
  assert(::mlir::succeeded(_result_funcName));
  return SpecializedRoutineAttr::get(odsParser.getContext(),
      SymbolRefAttr((*_result_routine)),
      ParLevelAttr((*_result_level)),
      StringAttr((*_result_funcName)));
}

void SpecializedRoutineAttr::print(::mlir::AsmPrinter &odsPrinter) const {
  ::mlir::Builder odsBuilder(getContext());
  odsPrinter << "<";
  odsPrinter.printStrippedAttrOrType(getRoutine());
  odsPrinter << ",";
  odsPrinter << ' ';
  odsPrinter.printStrippedAttrOrType(getLevel());
  odsPrinter << ",";
  odsPrinter << ' ';
  odsPrinter.printStrippedAttrOrType(getFuncName());
  odsPrinter << ">";
}

SymbolRefAttr SpecializedRoutineAttr::getRoutine() const {
  return getImpl()->routine;
}

ParLevelAttr SpecializedRoutineAttr::getLevel() const {
  return getImpl()->level;
}

StringAttr SpecializedRoutineAttr::getFuncName() const {
  return getImpl()->funcName;
}


} // namespace mlir::acc
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::acc::SpecializedRoutineAttr)
namespace mlir::acc {

namespace detail {

struct GPUParallelDimAttrStorage : public ::mlir::AttributeStorage {
  using KeyTy = std::tuple<::mlir::IntegerAttr>;
  GPUParallelDimAttrStorage(::mlir::IntegerAttr value) : value(std::move(value)) {}

  KeyTy getAsKey() const {
    return KeyTy(value);
  }

  bool operator==(const KeyTy &tblgenKey) const {
    return (value == std::get<0>(tblgenKey));
  }

  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
    return ::llvm::hash_combine(std::get<0>(tblgenKey));
  }

  static GPUParallelDimAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
    auto value = std::move(std::get<0>(tblgenKey));
    return new (allocator.allocate<GPUParallelDimAttrStorage>()) GPUParallelDimAttrStorage(std::move(value));
  }

  ::mlir::IntegerAttr value;
};

} // namespace detail
GPUParallelDimAttr GPUParallelDimAttr::get(::mlir::MLIRContext *context, ::mlir::IntegerAttr value) {
  return Base::get(context, std::move(value));
}

::mlir::IntegerAttr GPUParallelDimAttr::getValue() const {
  return getImpl()->value;
}


} // namespace mlir::acc
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::acc::GPUParallelDimAttr)
namespace mlir::acc {

namespace detail {

struct GPUParallelDimsAttrStorage : public ::mlir::AttributeStorage {
  using KeyTy = std::tuple<::llvm::ArrayRef<::mlir::acc::GPUParallelDimAttr>>;
  GPUParallelDimsAttrStorage(::llvm::ArrayRef<::mlir::acc::GPUParallelDimAttr> array) : array(std::move(array)) {}

  KeyTy getAsKey() const {
    return KeyTy(array);
  }

  bool operator==(const KeyTy &tblgenKey) const {
    return (array == std::get<0>(tblgenKey));
  }

  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
    return ::llvm::hash_combine(std::get<0>(tblgenKey));
  }

  static GPUParallelDimsAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
    auto array = std::move(std::get<0>(tblgenKey));
    array = allocator.copyInto(array);
    return new (allocator.allocate<GPUParallelDimsAttrStorage>()) GPUParallelDimsAttrStorage(std::move(array));
  }

  ::llvm::ArrayRef<::mlir::acc::GPUParallelDimAttr> array;
};

} // namespace detail
GPUParallelDimsAttr GPUParallelDimsAttr::get(::mlir::MLIRContext *context, ::llvm::ArrayRef<::mlir::acc::GPUParallelDimAttr> array) {
  return Base::get(context, std::move(array));
}

::llvm::ArrayRef<::mlir::acc::GPUParallelDimAttr> GPUParallelDimsAttr::getArray() const {
  return getImpl()->array;
}


} // namespace mlir::acc
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::acc::GPUParallelDimsAttr)
namespace mlir::acc {


/// Parse an attribute registered to this dialect.
::mlir::Attribute OpenACCDialect::parseAttribute(::mlir::DialectAsmParser &parser,
                                      ::mlir::Type type) const {
  ::llvm::SMLoc typeLoc = parser.getCurrentLocation();
  ::llvm::StringRef attrTag;
  {
    ::mlir::Attribute attr;
    auto parseResult = generatedAttributeParser(parser, &attrTag, type, attr);
    if (parseResult.has_value())
      return attr;
  }
  
  parser.emitError(typeLoc) << "unknown attribute `"
      << attrTag << "` in dialect `" << getNamespace() << "`";
  return {};
}
/// Print an attribute registered to this dialect.
void OpenACCDialect::printAttribute(::mlir::Attribute attr,
                         ::mlir::DialectAsmPrinter &printer) const {
  if (::mlir::succeeded(generatedAttributePrinter(attr, printer)))
    return;
  
}

} // namespace mlir::acc

#endif // GET_ATTRDEF_CLASSES