fix(encode): support arrays and label Option<T> as optional (#855)

### Changelog
- Added derive(Encode) support for arrays.
- Marked Option<T> types as optional.

### Docs

None

### Description

- Added encoding for arrays following the same format as Vec
- When an Option<T> is None, currently the field is not written at all
but the field is still marked as Required. Changed it to optional.

---------

Co-authored-by: Greg Smith <gasmith@foxglove.dev>

Author: ritvik-saronic

rust/foxglove/src/protobuf.rs

@@ -126,6 +126,13 @@ pub trait ProtobufField {
         false
     }
 
+    /// Indicates the type represents an optional field (like an Option).
+    ///
+    /// By default, fields are not optional.
+    fn optional() -> bool {
+        false
+    }
+
     /// The length of the field to be written, in bytes (not including the tag).
     fn encoded_len(&self) -> usize;
 
@@ -452,6 +459,10 @@ where
         true
     }
 
+    fn enum_descriptor() -> Option<prost_types::EnumDescriptorProto> {
+        T::enum_descriptor()
+    }
+
     fn message_descriptor() -> Option<prost_types::DescriptorProto> {
         // The message descriptor of a vector is the message descriptor of the element type
         // the "repeating" property is set on the field that is repeating rather than the message
@@ -483,6 +494,70 @@ where
     }
 }
 
+// implement a protobuf field for any array [T; N] where T implements ProtobufField
+impl<T, const N: usize> ProtobufField for [T; N]
+where
+    T: ProtobufField,
+{
+    fn field_type() -> ProstFieldType {
+        T::field_type()
+    }
+
+    fn wire_type() -> u32 {
+        prost::encoding::WireType::LengthDelimited as u32
+    }
+
+    fn write_tagged(&self, field_number: u32, buf: &mut impl bytes::BufMut) {
+        // Non-packed repeated fields are encoded as a record for each element.
+        // https://protobuf.dev/programming-guides/encoding/#repeated
+        for value in self {
+            value.write_tagged(field_number, buf);
+        }
+    }
+
+    fn write(&self, _buf: &mut impl bytes::BufMut) {
+        panic!("[T; N] should always be written using write_tagged");
+    }
+
+    fn repeating() -> bool {
+        true
+    }
+
+    fn enum_descriptor() -> Option<prost_types::EnumDescriptorProto> {
+        T::enum_descriptor()
+    }
+
+    fn message_descriptor() -> Option<prost_types::DescriptorProto> {
+        // The message descriptor of an array is the message descriptor of the element type
+        // the "repeating" property is set on the field that is repeating rather than the message
+        // descriptor
+        T::message_descriptor()
+    }
+
+    fn file_descriptor() -> Option<prost_types::FileDescriptorProto> {
+        T::file_descriptor()
+    }
+
+    fn file_descriptors() -> Vec<prost_types::FileDescriptorProto> {
+        T::file_descriptors()
+    }
+
+    fn type_name() -> Option<String> {
+        T::type_name()
+    }
+
+    fn encoded_len(&self) -> usize {
+        self.iter().map(|value| value.encoded_len()).sum()
+    }
+
+    fn encoded_len_tagged(&self, field_number: u32) -> usize {
+        // Each element is written with its own tag, so sum up the tagged lengths.
+        self.iter()
+            .map(|value| value.encoded_len_tagged(field_number))
+            .sum()
+    }
+}
+
 // Implement ProtobufField for Option<T> where T implements ProtobufField.
 // In proto3, all fields are implicitly optional. None means the field is not written.
 impl<T> ProtobufField for Option<T>
@@ -532,6 +607,10 @@ where
         T::repeating()
     }
 
+    fn optional() -> bool {
+        true
+    }
+
     fn encoded_len(&self) -> usize {
         match self {
             Some(value) => value.encoded_len(),

rust/foxglove_derive/src/lib.rs

@@ -37,24 +37,67 @@ fn is_option(ty: &Type) -> bool {
     unwrap_generic_type(ty, "Option").is_some()
 }
 
+/// Check if a type is `[T; N]` for some T and N.
+fn is_array(ty: &Type) -> bool {
+    matches!(ty, Type::Array(_))
+}
+
+/// Extract the element type from an array type `[T; N]`.
+fn unwrap_array_type(ty: &Type) -> Option<&Type> {
+    match ty {
+        Type::Array(arr) => Some(&arr.elem),
+        _ => None,
+    }
+}
+
 /// Check if a type is `Vec<Option<T>>`, which is not supported because protobuf
 /// repeated fields cannot represent null/missing elements.
 fn is_vec_of_option(ty: &Type) -> bool {
     unwrap_generic_type(ty, "Vec").is_some_and(is_option)
 }
 
+/// Check if a type is `[Option<T>; N]`, which is not supported because protobuf
+/// repeated fields cannot represent null/missing elements.
+fn is_array_of_option(ty: &Type) -> bool {
+    unwrap_array_type(ty).is_some_and(is_option)
+}
+
 /// Check if a type is `Option<Vec<T>>`, which is not supported because protobuf
 /// cannot distinguish between "not present" and "empty list".
 fn is_option_of_vec(ty: &Type) -> bool {
     unwrap_generic_type(ty, "Option").is_some_and(is_vec)
 }
 
+/// Check if a type is `Option<[T; N]>`, which is not supported because protobuf
+/// cannot distinguish between "not present" and "empty array".
+fn is_option_of_array(ty: &Type) -> bool {
+    unwrap_generic_type(ty, "Option").is_some_and(is_array)
+}
+
 /// Check if a type is `Vec<Vec<T>>`, which is not supported because protobuf
 /// does not support nested repeated fields.
 fn is_vec_of_vec(ty: &Type) -> bool {
     unwrap_generic_type(ty, "Vec").is_some_and(is_vec)
 }
 
+/// Check if a type is `[Vec<T>; N]`, which is not supported because protobuf
+/// does not support nested repeated fields.
+fn is_array_of_vec(ty: &Type) -> bool {
+    unwrap_array_type(ty).is_some_and(is_vec)
+}
+
+/// Check if a type is `Vec<[T; N]>`, which is not supported because protobuf
+/// does not support nested repeated fields.
+fn is_vec_of_array(ty: &Type) -> bool {
+    unwrap_generic_type(ty, "Vec").is_some_and(is_array)
+}
+
+/// Check if a type is `[[T; M]; N]`, which is not supported because protobuf
+/// does not support nested repeated fields.
+fn is_array_of_array(ty: &Type) -> bool {
+    unwrap_array_type(ty).is_some_and(is_array)
+}
+
 /// Derive macro for enums and structs allowing them to be logged to a Foxglove channel.
 #[proc_macro_derive(Encode)]
 pub fn derive_loggable(input: TokenStream) -> TokenStream {
@@ -209,6 +252,36 @@ fn derive_struct_impl(input: &DeriveInput, data: &DataStruct) -> TokenStream {
             });
         }
 
+        if is_array_of_option(field_type) {
+            return TokenStream::from(quote! {
+                compile_error!("[Option<T>; N] is not supported. Protobuf repeated fields cannot represent null/missing elements.");
+            });
+        }
+
+        if is_option_of_array(field_type) {
+            return TokenStream::from(quote! {
+                compile_error!("Option<[T; N]> is not supported. Protobuf cannot distinguish between absent and empty repeated fields.");
+            });
+        }
+
+        if is_array_of_array(field_type) {
+            return TokenStream::from(quote! {
+                compile_error!("[[T; M]; N] is not supported. Protobuf does not support nested repeated fields.");
+            });
+        }
+
+        if is_array_of_vec(field_type) {
+            return TokenStream::from(quote! {
+                compile_error!("[Vec<T>; N] is not supported. Protobuf does not support nested repeated fields.");
+            });
+        }
+
+        if is_vec_of_array(field_type) {
+            return TokenStream::from(quote! {
+                compile_error!("Vec<[T; N]> is not supported. Protobuf does not support nested repeated fields.");
+            });
+        }
+
         field_tagged_lengths.push(quote! {
             ::foxglove::protobuf::ProtobufField::encoded_len_tagged(&self.#field_name, #field_number)
         });
@@ -240,6 +313,8 @@ fn derive_struct_impl(input: &DeriveInput, data: &DataStruct) -> TokenStream {
 
             if <#field_type as ::foxglove::protobuf::ProtobufField>::repeating() {
                 field.label = Some(::foxglove::prost_types::field_descriptor_proto::Label::Repeated as i32);
+            } else if <#field_type as ::foxglove::protobuf::ProtobufField>::optional() {
+                field.label = Some(::foxglove::prost_types::field_descriptor_proto::Label::Optional as i32);
             } else {
                 field.label = Some(::foxglove::prost_types::field_descriptor_proto::Label::Required as i32);
             }

rust/foxglove_derive/tests/enum_fields_test.rs

@@ -20,6 +20,16 @@ struct TestMessage {
     c: TestEnum,
 }
 
+#[derive(Encode)]
+struct TestMessageVecEnum {
+    values: Vec<TestEnum>,
+}
+
+#[derive(Encode)]
+struct TestMessageArrayEnum {
+    values: [TestEnum; 3],
+}
+
 #[test]
 fn test_single_enum_field_serialization() {
     let test_struct = TestMessage {
@@ -58,6 +68,86 @@ fn test_single_enum_field_serialization() {
     }
 }
 
+#[test]
+fn test_vec_of_enum_serialization() {
+    let test_struct = TestMessageVecEnum {
+        values: vec![TestEnum::ValueNeg, TestEnum::Value2, TestEnum::ValueOne],
+    };
+
+    let mut buf = BytesMut::new();
+    test_struct.encode(&mut buf).expect("Failed to encode");
+
+    let schema = TestMessageVecEnum::get_schema().expect("Failed to get schema");
+    assert_eq!(schema.encoding, "protobuf");
+
+    let message_descriptor = get_message_descriptor(&schema);
+
+    // Verify the field is marked as repeated
+    let field_descriptor = message_descriptor
+        .get_field_by_name("values")
+        .expect("Field 'values' not found");
+    assert!(
+        field_descriptor.is_list(),
+        "Field should be a repeated list"
+    );
+
+    let deserialized_message = DynamicMessage::decode(message_descriptor.clone(), buf.as_ref())
+        .expect("Failed to deserialize");
+
+    let field_value = deserialized_message.get_field(&field_descriptor);
+    let list_value = field_value.as_list().expect("Field value is not a list");
+
+    assert_eq!(list_value.len(), 3, "Vec should have 3 elements");
+
+    let expected_values = [-10, 2, 1];
+    for (i, expected) in expected_values.iter().enumerate() {
+        let value = list_value[i]
+            .as_enum_number()
+            .expect("List item should be an enum");
+        assert_eq!(value, *expected, "Enum value at index {} is wrong", i);
+    }
+}
+
+#[test]
+fn test_array_of_enum_serialization() {
+    let test_struct = TestMessageArrayEnum {
+        values: [TestEnum::ValueOne, TestEnum::ValueNeg, TestEnum::Value2],
+    };
+
+    let mut buf = BytesMut::new();
+    test_struct.encode(&mut buf).expect("Failed to encode");
+
+    let schema = TestMessageArrayEnum::get_schema().expect("Failed to get schema");
+    assert_eq!(schema.encoding, "protobuf");
+
+    let message_descriptor = get_message_descriptor(&schema);
+
+    // Verify the field is marked as repeated
+    let field_descriptor = message_descriptor
+        .get_field_by_name("values")
+        .expect("Field 'values' not found");
+    assert!(
+        field_descriptor.is_list(),
+        "Field should be a repeated list"
+    );
+
+    let deserialized_message = DynamicMessage::decode(message_descriptor.clone(), buf.as_ref())
+        .expect("Failed to deserialize");
+
+    let field_value = deserialized_message.get_field(&field_descriptor);
+    let list_value = field_value.as_list().expect("Field value is not a list");
+
+    assert_eq!(list_value.len(), 3, "Array should have 3 elements");
+
+    let expected_values = [1, -10, 2];
+    for (i, expected) in expected_values.iter().enumerate() {
+        let value = list_value[i]
+            .as_enum_number()
+            .expect("List item should be an enum");
+        assert_eq!(value, *expected, "Enum value at index {} is wrong", i);
+    }
+}
+
 fn get_message_descriptor(schema: &Schema) -> MessageDescriptor {
     let descriptor_set = prost_types::FileDescriptorSet::decode(schema.data.as_ref())
         .expect("Failed to decode descriptor set");