" not in tf functional dialect";
      op->emitError() << error;
      return WalkResult::interrupt();
    }

    if (op->hasAttr(mlir::TF::kXlaOutsideCompilationAttr)) {
      std::string error =
          "op has outside compilation attribute _xla_outside_compilation which "
          "is not allowed after clustering";
      op->emitError() << error;
      return mlir::WalkResult::interrupt();
    }

  if (!llvm::hasSingleElement(body))
    return parser.emitError(loc) << "expects a single block region";

  // Get the results type from the terminator type inside the graph.
  Operation &fetch = body.back().back();
  if (!isa<FetchOp>(fetch))
    return parser.emitError(loc) << "expects a tf_executor.fetch terminator";

    return func->emitError()
           << "'" << attr_name << "' attribute for " << kMaxUnpooling
           << " must be set and has size of " << N;
  }
  results->reserve(N);

  for (Attribute integer_attr : array_attr.getValue()) {
    IntegerAttr value = mlir::dyn_cast<IntegerAttr>(integer_attr);
    if (!value) {
      return func->emitError()

  if (current_device->empty()) {
    func.emitError(
        "cannot find target annotation or unknown device specified for current "
        "function");
    return;
  }

  auto current_inference_type = GetInferenceTypeAnnotation(func);
  if (!current_inference_type.has_value() ||
      current_inference_type == UNKNOWN) {
    func.emitError(

  Block& block = function.front();

  const tensorflow::DeviceMgr* mgr = nullptr;
  auto status = session->LocalDeviceManager(&mgr);
  if (!status.ok())
    return function->emitError(
        absl::StrCat("failed to fetch device manager: ", status.message()));

  // Fetch all varHandleOp in the function.
  llvm::SmallVector<TF::VarHandleOp, 4> var_ops;

      // GuaranteeAllFuncsOneUsePass to remove "tf.entry_function" or
      // "tf_saved_model.initializer_type" attribute from the callee of the
      // inner calls if the problem ever arises.
      entry_func->emitError()
          << "TF2XLA MLIR Non-replicated Phase 1 Bridge expects no nested calls"
             " of entry functions as they prevent graph traversal in some "
             "passes from "
             "working correctly";

                                          Location loc) {
  auto dims_type = mlir::dyn_cast<RankedTensorType>(dims.getType());
  if (!dims_type) return success();
  if (dims_type.getRank() > 1)
    return emitError(loc, "dimensions can only be 0D or 1D tensor");

  auto input_type = mlir::dyn_cast<RankedTensorType>(input.getType());
  if (!input_type) return success();
  int64_t rank = input_type.getRank();

  RewritePatternSet patterns(context);
  stablehlo::populateStablehloToVhloPatterns(&patterns, &converter, context);

  if (failed(applyPartialConversion(module, target, std::move(patterns)))) {
    return module->emitError("Failed partial conversion to VHLO");
  }
  return success();
}

LogicalResult ApplyVhloToVersionPatterns(ModuleOp module,
                                         const std::string &version) {

  DeviceNameUtils::ParsedName parsed_name;
  if (!DeviceNameUtils::ParseFullName(
          absl::string_view(device.data(), device.size()), &parsed_name))
    return mlir::emitError(loc) << "invalid device '" << device << "'";

  if (!parsed_name.has_id)
    return mlir::emitError(loc) << "device '" << device << "' has no id";

  *device_ordinal = parsed_name.id;
  return mlir::success();
}

      failed(AddFloatAttr(func, attrs, "w_scale", &fbb)))
    return failure();
  auto use_regular_nms =
      mlir::dyn_cast_or_null<BoolAttr>(attrs.get("use_regular_nms"));
  if (!use_regular_nms) {
    return func.emitError()
           << "use_regular_nms attribute is not set or not a bool";
  }
  fbb.Int("use_regular_nms", use_regular_nms.getValue());

  fbb.EndMap(start_map);
  fbb.Finish();