def METHOD_NAME(cls, op: "TensorRechunk"):
    from ..indexing.slice import TensorSlice
    from ..merge.concatenate import TensorConcatenate
    if has_unknown_shape(*op.inputs):
        yield
    out = op.outputs[0]
    tensor = astensor(op.inputs[0])
    chunk_size = get_nsplits(tensor, op.chunk_size, tensor.dtype.itemsize)
    if chunk_size == tensor.nsplits:
        return [tensor]
    rechunk_infos = gen_rechunk_infos(tensor, chunk_size)
    out_chunks = []
    for rechunk_info in rechunk_infos:
        chunk_index = rechunk_info.out_index
        shape = rechunk_info.shape
        inp_chunks = rechunk_info.input_chunks
        inp_chunk_slices = rechunk_info.input_slices
        inp_slice_chunks = []
        for inp_chunk, inp_chunk_slice in zip(inp_chunks, inp_chunk_slices):
            if all(slc == slice(None) for slc in inp_chunk_slice):
                inp_slice_chunks.append(inp_chunk)
            else:
                slc_chunk = TensorSlice(slices=list(inp_chunk_slice)).new_chunk(
                    [inp_chunk],
                    dtype=inp_chunk.dtype,
                    shape=tuple(
                        calc_sliced_size(s, slc)
                        for s, slc in zip(inp_chunk.shape, inp_chunk_slice)
                    ),
                    index=inp_chunk.index,
                )
                inp_slice_chunks.append(slc_chunk)
        if len(inp_slice_chunks) > 1 or inp_slice_chunks[0].index != chunk_index:
            chunk_op = TensorConcatenate()
            out_chunk = chunk_op.new_chunk(
                inp_slice_chunks,
                shape=shape,
                index=chunk_index,
                dtype=out.dtype,
                order=out.order,
            )
            out_chunks.append(out_chunk)
        else:
            out_chunks.append(inp_slice_chunks[0])
    new_op = op.copy()
    params = out.params
    params["nsplits"] = chunk_size
    params["chunks"] = out_chunks
    tensor = new_op.new_tileable(op.inputs, kws=[params])
    if op.reassign_worker:
        for c in tensor.chunks:
            c.op.reassign_worker = True
    return [tensor]