if (!input_type || !mlir::isa<StringType>(input_type.getElementType()) ||
      !input_type.hasRank()) {
    return func.emitError() << "Input should be a string tensor";
  }

  const std::vector<int> kValidNumOfOutput = {1, 2, 3};
  if (input_type.getRank() >= kValidNumOfOutput.size()) {
    return func.emitError()
           << "Unrecognized input rank: " << input_type.getRank();
  }

      return global_tensor.emitError()
             << "'type' and 'value' attributes should "
                "have compatible tensor types";
    }
  }
  if (!global_tensor.getIsMutable()) {
    if (!mlir::cast<TensorType>(global_tensor.getType()).hasStaticShape()) {
      return global_tensor.emitError()
             << "'type' attribute for immutable 'tf_saved_model.global_tensor' "

      // check too.
      op.emitError() << "Input tensor [" << input_index
                     << "] is a state tensor, but has more than one use.";
      return failure();
    }
    auto stats = mlir::dyn_cast<DenseFPElementsAttr>(stats_op.getLayerStats());
    if (!stats || stats.getNumElements() != 2) {
      stats_op.emitError("Stats should have 2 values.");
      return failure();
    }

    if (!flexbuffers::VerifyBuffer(opt_data, opt_size)) {
      return emitError(loc, "invalid custom options");
    }

    const flexbuffers::Vector& v =
        flexbuffers::GetRoot(opt_data, opt_size).AsVector();

    op_name = v[0].AsString().str();

    if (!node_def.ParseFromString(v[1].AsString().str())) {
      return emitError(
          loc, "failed to parse 'custom_options' data into a valid NodeDef");

  if (!output_tensor_type || !output_tensor_type.hasStaticShape()) {
    op.emitError("output type should be static and ranked.");
    return failure();
  }

  if (output_tensor_type.getRank() == 0) {
    bool same_scalar = output_tensor_type.getElementType() == input_type;
    if (!same_scalar) {
      op.emitError("input and output should have the same scalar types.");
    }
    return success(same_scalar);

            sharding)
            .failed()) {
      return cluster_func.emitError("incorrect sharding format for inputs");
    }

    const auto input_sharding_type = sharding.type();

    auto tiled_sharding_mismatched = [&](int tiled_input_size) {
      return cluster_func.emitError(
          llvm::formatv("incorrect {0}-th tiled input sharding received. "

  attr.getValue().split(attr_tokens, ",");
  if (attr_tokens.empty()) {
    return fused_func_op_.emitError()
           << kTFImplements << " attribute should be set";
  }

  // Check if the interface matches.
  if (GetCompositeOpName().str() != attr_tokens[0]) {
    return fused_func_op_.emitError()
           << "Unexpected interface for the composite op. Expected: "

  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";

  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(

  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) {