如何解决ts-proto与prost序列化空数值数组的兼容性问题？

针对空数值数组序列化的兼容性问题，以下是比嵌入JS或fork prost更优的方案：

方案一：自定义消息包装类型（推荐，适合Rust新手） #

通过包装prost生成的消息结构体，手动实现prost::Message trait来控制空数组的序列化行为，无需修改生成代码或依赖外部环境。

示例实现（针对单个消息） #

假设你的proto定义了包含空数组字段的Foo消息：

message Foo {
  repeated int32 bars = 1; // packed类型，ts-proto会输出tag+0字节，prost默认跳过
}

在Rust中定义包装类型并实现prost::Message：

use prost::{Message, bytes::BufMut, encoding};

// 包装生成的Foo结构体
struct CompatibleFoo(pub Foo);

impl Message for CompatibleFoo {
    fn encode_raw<B>(&self, buf: &mut B)
    where
        B: BufMut,
    {
        // 先让prost正常序列化非空字段
        self.0.encode_raw(buf);
        
        // 空数组时手动写入tag和0长度（对应字段1的packed类型：tag=0x0a，长度0=0x00）
        if self.0.bars.is_empty() {
            buf.put_u8(0x0a);
            buf.put_u8(0x00);
        }
    }

    fn merge_field<B>(
        &mut self,
        tag: u32,
        wire_type: encoding::WireType,
        buf: &mut B,
        ctx: encoding::DecodeContext,
    ) -> Result<(), prost::DecodeError>
    where
        B: prost::bytes::Buf,
    {
        // 委托给原生Foo处理解析逻辑
        self.0.merge_field(tag, wire_type, buf, ctx)
    }

    fn encoded_len(&self) -> usize {
        let mut len = self.0.encoded_len();
        // 空数组时额外加2字节（tag+长度）
        if self.0.bars.is_empty() {
            len += 2;
        }
        len
    }

    fn clear(&mut self) {
        self.0.clear();
    }
}

嵌套消息处理 #

如果Foo是其他消息的属性（比如Bar包含Foo），只需为Bar也创建包装类型，在序列化时使用CompatibleFoo替代原生Foo即可：

struct CompatibleBar(pub Bar);

impl Message for CompatibleBar {
    fn encode_raw<B>(&self, buf: &mut B)
    where
        B: BufMut,
    {
        // 先序列化Bar的其他字段（临时移除foo字段）
        let mut temp_bar = self.0.clone();
        let foo = temp_bar.foo.take();
        temp_bar.encode_raw(buf);

        // 处理嵌套的Foo字段
        if let Some(foo) = foo {
            // 写入Foo字段的tag（字段1，wire类型为长度前缀）
            buf.put_u8(0x0a);
            let compatible_foo = CompatibleFoo(foo);
            // 写入嵌套消息的长度
            encoding::encode_varint(compatible_foo.encoded_len() as u64, buf);
            // 序列化兼容版Foo
            compatible_foo.encode_raw(buf);
        }
    }

    // 其他方法同样委托给原生Bar处理
    fn merge_field<B>(
        &mut self,
        tag: u32,
        wire_type: encoding::WireType,
        buf: &mut B,
        ctx: encoding::DecodeContext,
    ) -> Result<(), prost::DecodeError>
    where
        B: prost::bytes::Buf,
    {
        self.0.merge_field(tag, wire_type, buf, ctx)
    }

    fn encoded_len(&self) -> usize {
        let mut len = self.0.encoded_len();
        if let Some(foo) = &self.0.foo {
            if foo.bars.is_empty() {
                // 加上嵌套Foo的额外2字节+字段tag+长度的字节数
                len += 2 + encoding::varint_len((self.0.encoded_len() + 2) as u64);
            }
        }
        len
    }

    fn clear(&mut self) {
        self.0.clear();
    }
}

方案二：自定义prost代码生成钩子（适合多字段场景） #

如果有大量需要兼容的空数组字段，可以通过prost_build的代码生成钩子，自动修改生成的encode_raw方法，统一处理空数组序列化。

在build.rs中添加钩子逻辑：

use prost_build::{Config, Tree};

fn main() {
    let mut config = Config::new();
    config.after_parse(|tree| {
        // 遍历所有消息和字段，找到需要兼容的repeated数值字段
        if let Tree::Message(msg) = tree {
            if msg.name == "Foo" {
                for field in msg.fields.iter_mut() {
                    if field.name == "bars" && field.r#type.is_repeated() {
                        // 修改该字段的生成代码，强制写入空数组的tag+0长度
                        // 替换prost默认的空数组跳过逻辑，改为手动写入
                        field.codegen_protobuf_type = "::prost::alloc::vec::Vec<i32>".to_string();
                        // 此处需自定义代码片段，覆盖生成的序列化逻辑
                    }
                }
            }
        }
        Ok(())
    });

    config.compile_protos(&["proto/foo.proto"], &["proto/"]).unwrap();
}

注：此方案需要熟悉prost的代码生成模板，适合有一定Rust基础的开发者。

方案三：手动修改生成代码（临时快速方案） #

如果代码规模小、字段少，可以直接修改prost生成的encode_raw方法，添加空数组的序列化逻辑：

找到生成的Foo结构体的encode_raw方法，将原本的空数组跳过逻辑：

if !self.bars.is_empty() {
    prost::encoding::encode_packed::<i32, _>(1, &self.bars, buf);
}

替换为：

if self.bars.is_empty() {
    buf.put_u8(0x0a); // 字段1的packed类型tag
    buf.put_u8(0x00); // 0长度
} else {
    prost::encoding::encode_packed::<i32, _>(1, &self.bars, buf);
}

缺点：每次重新生成proto代码都需要重复修改，适合临时调试或小项目。

内容的提问来源于stack exchange，提问作者Haardik