buffer_shape.push_back(dim);
  }
  auto zero = CreateScalarConst(0, builder, op->getLoc());
  if (getElementTypeOrSelf(zero.getType()) != element_dtype) {
    zero = builder.create<TF::CastOp>(
        op->getLoc(),
        ArrayRef<Type>{tensorflow::GetTypeFromTFTensorShape({}, element_dtype)},
        ArrayRef<Value>{zero});
  }
  auto buffer_type =

    ShapedType new_type =
        RankedTensorType::get(shaped_type.getShape(), new_ele_type);
    return rewriter.createOrFold<TF::CastOp>(loc, new_type, val,
                                             rewriter.getBoolAttr(false));
  }
  return rewriter.createOrFold<TF::CastOp>(
      loc, UnrankedTensorType::get(new_ele_type), val,
      rewriter.getBoolAttr(false));
}

// Utility function to-

  return mlir::isa<TF::ResourceType>(getElementTypeOrSelf(value.getType()));
}

// Checks if a cast op is casting a resource -> resource.
bool IsCastOfResource(Operation &op) {
  auto cast = dyn_cast<TF::CastOp>(op);
  if (!cast) return false;
  return IsResource(cast.getX());
}

// Removes passthrough ops in the block. The device computation does not need
// such nodes to carry information.

        // CaseOp isn't actually supported but is enabled for testing to
        // make sure ops with symbol ref attributes are filtered out.
        TypeID::get<TF::CaseOp>(),
        TypeID::get<TF::CastOp>(),
        TypeID::get<TF::ClipByValueOp>(),
        TypeID::get<TF::CholeskyOp>(),
        TypeID::get<TF::CollectiveReduceV2Op>(),
        TypeID::get<TF::ComplexAbsOp>(),

        RankedTensorType::get(transpose_params.canonicalized_output_shape,
                              result_type.getElementType());

    TF::CastOp cast_op = nullptr;
    if (start_indices_type.getElementType().isUnsignedInteger(32)) {
      cast_op = rewriter.create<TF::CastOp>(
          gather_op->getLoc(),
          RankedTensorType::get(start_indices_type.getShape(),
                                rewriter.getI64Type()),

      // CastOp if the shape of types doesn't exactly match.
      Type read_type = read_variable_op.getValue().getType();
      if (read_type != last_store.getValue().getType()) {
        OpBuilder builder(last_store);
        builder.setInsertionPointAfter(last_store);
        auto cast = builder.create<TF::CastOp>(
            last_store.getLoc(), read_type, last_store.getValue(),

        for (auto operand : op->getOperands()) {
          PropagateInputToOutput(operand, result);
        }
      }
    } else if (llvm::isa<IdentityNOp, IdentityOp, CastOp>(op)) {
      for (auto result : filter_resources(op->getResults()))
        PropagateInputToOutput(op->getOperand(result.getResultNumber()),
                               result);

  auto func_result_type = tensorflow::GetTypeFromTFTensorShape(
      func_output_shape,
      mlir::cast<RankedTensorType>(input_.getType()).getElementType());

  auto tensor_cast = builder_.create<mlir::tensor::CastOp>(
      fused_func_op_.getLoc(), func_result_type, lstm_.getResult());
  builder_.create<mlir::func::ReturnOp>(fused_func_op_.getLoc(),
                                        tensor_cast.getResult());
  return success();

                                       Location conversion_loc) const final {
    if (!mlir::isa<TensorType>(result_type) ||
        !mlir::isa<TensorType>(input.getType()))
      return nullptr;
    return builder.create<TF::CastOp>(conversion_loc, result_type, input,
                                      /*truncate=*/builder.getBoolAttr(false));
  }
};

// Checks if a block wraps a single operation and the single operation results

    mlir::RankedTensorType buffer_ty = result_ty;
    if (!buffer_ty.hasStaticShape()) {
      mlir::Value return_val = return_op->getOperand(idx);
      if (auto owner = mlir::dyn_cast_or_null<mlir::tensor::CastOp>(
              return_val.getDefiningOp())) {
        // For bounded dynamic type, get a static size by taking bounds as the
        // dimensions. These dimensions are marked as dynamic in xla::Shape
        // below.