feat(rust): generate setters for optional enum fields too

Leonardo Arcari · Leonardo Arcari · commit 50fab5bf09f0 · 2026-02-18T17:23:09.000+01:00
diff --git a/build.gradle b/build.gradle
@@ -679,6 +679,7 @@ tasks.register('generateRustTestCodecs', JavaExec) {
             'sbe-tool/src/test/resources/issue1028.xml',
             'sbe-tool/src/test/resources/issue1057.xml',
             'sbe-tool/src/test/resources/issue1066.xml',
+            'sbe-tool/src/test/resources/optional_enum_nullify.xml',
             'sbe-tool/src/test/resources/fixed-sized-primitive-array-types.xml',
             'sbe-tool/src/test/resources/example-bigendian-test-schema.xml',
             'sbe-tool/src/test/resources/nested-composite-name.xml',
diff --git a/rust/Cargo.toml b/rust/Cargo.toml
@@ -19,6 +19,7 @@ issue_987 = { path = "../generated/rust/issue987" }
 issue_1028 = { path = "../generated/rust/issue1028" }
 issue_1057 = { path = "../generated/rust/issue1057" }
 issue_1066 = { path = "../generated/rust/issue1066" }
+optional_enum_nullify = { path = "../generated/rust/optional_enum_nullify" }
 baseline_bigendian = { path = "../generated/rust/baseline-bigendian" }
 nested_composite_name = { path = "../generated/rust/nested-composite-name" }
 fixed_sized_primitive_array = { path = "../generated/rust/fixed_sized_primitive_array" }
diff --git a/rust/tests/optional_field_nullify_test.rs b/rust/tests/optional_field_nullify_test.rs
@@ -1,7 +1,5 @@
 use examples_extension as ext;
 use examples_uk_co_real_logic_sbe_benchmarks_fix as mqfix;
-use issue_895 as i895;
-use issue_972 as i972;
 use ext::{
     boolean_type::BooleanType as ExtBooleanType,
     boost_type::BoostType as ExtBoostType,
@@ -12,9 +10,7 @@ use ext::{
     message_header_codec::{self as ext_header, MessageHeaderDecoder as ExtHeaderDecoder},
     model::Model as ExtModel,
     optional_extras::OptionalExtras as ExtOptionalExtras,
-    ReadBuf as ExtReadBuf,
-    SbeResult as ExtSbeResult,
-    WriteBuf as ExtWriteBuf,
+    ReadBuf as ExtReadBuf, SbeResult as ExtSbeResult, WriteBuf as ExtWriteBuf,
 };
 use i895::{
     issue_895_codec::{Issue895Decoder, Issue895Encoder},
@@ -26,6 +22,8 @@ use i972::{
     message_header_codec::{self as i972_header, MessageHeaderDecoder as I972HeaderDecoder},
     Either as I972Either, ReadBuf as I972ReadBuf, WriteBuf as I972WriteBuf,
 };
+use issue_895 as i895;
+use issue_972 as i972;
 use mqfix::{
     mass_quote_codec::{
         encoder::{QuoteEntriesEncoder, QuoteSetsEncoder},
@@ -34,15 +32,23 @@ use mqfix::{
     message_header_codec::{self as mqfix_header, MessageHeaderDecoder as MassQuoteHeaderDecoder},
     ReadBuf as MassQuoteReadBuf, WriteBuf as MassQuoteWriteBuf,
 };
+use oen::{
+    enum_type::EnumType as OenEnumType,
+    message_header_codec::{
+        self as oen_header, MessageHeaderDecoder as OptionalEnumNullifyHeaderDecoder,
+    },
+    optional_encoding_enum_type::OptionalEncodingEnumType as OenOptionalEncodingEnumType,
+    optional_enum_nullify_codec::{OptionalEnumNullifyDecoder, OptionalEnumNullifyEncoder},
+    ReadBuf as OenReadBuf, WriteBuf as OenWriteBuf,
+};
+use optional_enum_nullify as oen;
 
 type TestResult = Result<(), Box<dyn std::error::Error>>;
 
 macro_rules! create_encoder_with_header_parent {
     ($buffer:expr, $encoder_ty:ty, $write_buf_ty:ty, $encoded_len:expr) => {{
-        let encoder = <$encoder_ty>::default().wrap(
-            <$write_buf_ty>::new($buffer.as_mut_slice()),
-            $encoded_len,
-        );
+        let encoder = <$encoder_ty>::default()
+            .wrap(<$write_buf_ty>::new($buffer.as_mut_slice()), $encoded_len);
         let mut header = encoder.header(0);
         header.parent().unwrap()
     }};
@@ -66,6 +72,15 @@ fn create_issue_972_encoder(buffer: &mut Vec<u8>) -> Issue972Encoder<'_> {
     )
 }
 
+fn create_optional_enum_nullify_encoder(buffer: &mut Vec<u8>) -> OptionalEnumNullifyEncoder<'_> {
+    create_encoder_with_header_parent!(
+        buffer,
+        OptionalEnumNullifyEncoder<'_>,
+        OenWriteBuf<'_>,
+        oen_header::ENCODED_LENGTH
+    )
+}
+
 fn create_mass_quote_encoder(buffer: &mut Vec<u8>) -> MassQuoteEncoder<'_> {
     create_encoder_with_header_parent!(
         buffer,
@@ -87,6 +102,12 @@ fn decode_issue_972(buffer: &[u8]) -> Issue972Decoder<'_> {
     Issue972Decoder::default().header(header, 0)
 }
 
+fn decode_optional_enum_nullify(buffer: &[u8]) -> OptionalEnumNullifyDecoder<'_> {
+    let buf = OenReadBuf::new(buffer);
+    let header = OptionalEnumNullifyHeaderDecoder::default().wrap(buf, 0);
+    OptionalEnumNullifyDecoder::default().header(header, 0)
+}
+
 fn encode_extension_car_for_optional_field_test(
     cup_holder_count: Option<u8>,
     nullify: bool,
@@ -356,3 +377,51 @@ fn group_nullify_optional_fields_sets_optional_fields_to_none() -> TestResult {
 
     Ok(())
 }
+
+#[test]
+fn nullify_optional_fields_sets_optional_enum_field_to_null_value() -> TestResult {
+    use oen::Encoder;
+    let mut control_buffer = vec![0u8; 256];
+    let mut control_encoder = create_optional_enum_nullify_encoder(&mut control_buffer);
+    // Optionality is declared on the field, matching IR optional enum semantics.
+    control_encoder.optional_enum_opt(Some(OenEnumType::One));
+    // This field is required, even if its enum type encoding is optional.
+    control_encoder.required_enum_from_optional_type(OenOptionalEncodingEnumType::Alpha);
+
+    let control_decoder = decode_optional_enum_nullify(control_buffer.as_slice());
+    assert_eq!(OenEnumType::One, control_decoder.optional_enum());
+    assert_eq!(
+        OenOptionalEncodingEnumType::Alpha,
+        control_decoder.required_enum_from_optional_type()
+    );
+
+    let mut none_buffer = vec![0u8; 256];
+    let mut none_encoder = create_optional_enum_nullify_encoder(&mut none_buffer);
+    none_encoder.optional_enum_opt(None);
+    none_encoder.required_enum_from_optional_type(OenOptionalEncodingEnumType::Beta);
+
+    let none_decoder = decode_optional_enum_nullify(none_buffer.as_slice());
+    assert_eq!(OenEnumType::NullVal, none_decoder.optional_enum());
+    assert_eq!(
+        OenOptionalEncodingEnumType::Beta,
+        none_decoder.required_enum_from_optional_type()
+    );
+
+    let mut nullified_buffer = vec![0u8; 256];
+    let mut nullified_encoder = create_optional_enum_nullify_encoder(&mut nullified_buffer);
+    nullified_encoder.optional_enum_opt(Some(OenEnumType::Two));
+    nullified_encoder.required_enum_from_optional_type(OenOptionalEncodingEnumType::Beta);
+    // This is the behavior under test: nullify should route through *_opt(None)
+    // only for field-optional members, so `optional_enum` becomes NullVal while
+    // the required field remains unchanged even if its enum type encoding is optional.
+    nullified_encoder.nullify_optional_fields();
+
+    let nullified_decoder = decode_optional_enum_nullify(nullified_buffer.as_slice());
+    assert_eq!(OenEnumType::NullVal, nullified_decoder.optional_enum());
+    assert_eq!(
+        OenOptionalEncodingEnumType::Beta,
+        nullified_decoder.required_enum_from_optional_type()
+    );
+
+    Ok(())
+}
diff --git a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/MessageCoderDef.java b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/MessageCoderDef.java
@@ -72,8 +72,8 @@ void generate(
 
         if (codecType == Encoder)
         {
-            final List<String> optionalPrimitiveFields = RustGenerator.getOptionalPrimitiveFields(fields);
-            RustGenerator.appendImplEncoderTrait(sb, msgTypeName, optionalPrimitiveFields);
+            final List<String> optionalFields = RustGenerator.getNullifyOptionalFields(fields);
+            RustGenerator.appendImplEncoderTrait(sb, msgTypeName, optionalFields);
         }
         else
         {
diff --git a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java
@@ -224,23 +224,29 @@ static String getBufOffset(final Token token)
         return "offset";
     }
 
-    static List<String> getOptionalPrimitiveFields(final List<Token> tokens)
+    static List<String> getNullifyOptionalFields(final List<Token> tokens)
     {
-        final List<String> optionalPrimitiveFields = new ArrayList<>();
+        final List<String> optionalFields = new ArrayList<>();
         Generators.forEachField(
             tokens,
             (fieldToken, typeToken) ->
             {
-                final String name = fieldToken.name();
-                if (Objects.requireNonNull(typeToken.signal()) == Signal.ENCODING)
+                final String fieldName = formatFunctionName(fieldToken.name());
+                final Signal signal = Objects.requireNonNull(typeToken.signal());
+                if (signal == Signal.ENCODING)
                 {
                     if (isOptionalPrimitiveScalar(typeToken))
                     {
-                        optionalPrimitiveFields.add(formatFunctionName(name));
+                        optionalFields.add(fieldName);
                     }
                 }
+                else if (signal == BEGIN_ENUM &&
+                    isOptionalEnum(typeToken, fieldToken))
+                {
+                    optionalFields.add(fieldName);
+                }
             });
-        return optionalPrimitiveFields;
+        return optionalFields;
     }
 
     static void generateEncoderFields(
@@ -266,6 +272,10 @@ static void generateEncoderFields(
                             break;
                         case BEGIN_ENUM:
                             generateEnumEncoder(sb, level, fieldToken, typeToken, name);
+                            if (isOptionalEnum(typeToken, fieldToken))
+                            {
+                                generateOptionalEnumEncoder(sb, level, typeToken, name);
+                            }
                             break;
                         case BEGIN_SET:
                             generateBitSetEncoder(sb, level, typeToken, name);
@@ -287,12 +297,12 @@ static void generateEncoderFields(
     static void generateNullifyOptionalFieldsMethod(
         final Appendable out,
         final int level,
-        final List<String> optionalPrimitiveFields) throws IOException
+        final List<String> optionalFields) throws IOException
     {
-        indent(out, level, "/// Set all optional primitive scalar fields to their null values.\n");
+        indent(out, level, "/// Set all optional fields to their null values.\n");
         indent(out, level, "#[inline]\n");
         indent(out, level, "pub fn nullify_optional_fields(&mut self) -> &mut Self {\n");
-        for (final String field : optionalPrimitiveFields)
+        for (final String field : optionalFields)
         {
             indent(out, level + 1, "self.%s_opt(None);\n", field);
         }
@@ -305,6 +315,18 @@ private static boolean isOptionalPrimitiveScalar(final Token typeToken)
         return typeToken.arrayLength() == 1 && typeToken.encoding().presence() == Encoding.Presence.OPTIONAL;
     }
 
+    private static boolean isOptionalEnum(final Token typeToken, final Token fieldToken)
+    {
+        return typeToken.signal() == BEGIN_ENUM && fieldToken.isOptionalEncoding();
+    }
+
+    private static String rustEnumType(final Token typeToken)
+    {
+        final String referencedName = typeToken.referencedName();
+        final String enumTypeName = referencedName == null ? typeToken.name() : referencedName;
+        return format("%s::%s", toLowerSnakeCase(enumTypeName), formatStructName(enumTypeName));
+    }
+
     static void generateEncoderGroups(
         final StringBuilder sb,
         final List<Token> tokens,
@@ -642,10 +664,7 @@ private static void generateEnumEncoder(
         final Token typeToken,
         final String name) throws IOException
     {
-        final String referencedName = typeToken.referencedName();
-        final String enumType = format("%s::%s",
-            toLowerSnakeCase(referencedName == null ? typeToken.name() : referencedName),
-            formatStructName(referencedName == null ? typeToken.name() : referencedName));
+        final String enumType = rustEnumType(typeToken);
 
         if (fieldToken.isConstantEncoding())
         {
@@ -667,6 +686,27 @@ private static void generateEnumEncoder(
         }
     }
 
+    private static void generateOptionalEnumEncoder(
+        final StringBuilder sb,
+        final int level,
+        final Token typeToken,
+        final String name) throws IOException
+    {
+        final String functionName = formatFunctionName(name);
+        final String enumType = rustEnumType(typeToken);
+
+        indent(sb, level, "/// optional enum field '%s'\n", name);
+        generateRustDoc(sb, level, typeToken, typeToken.encoding());
+        indent(sb, level, "/// Set to `None` to encode the field null value.\n");
+        indent(sb, level, "#[inline]\n");
+        indent(sb, level, "pub fn %s_opt(&mut self, value: Option<%s>) {\n", functionName, enumType);
+        indent(sb, level + 1, "match value {\n");
+        indent(sb, level + 2, "Some(value) => self.%s(value),\n", functionName);
+        indent(sb, level + 2, "None => self.%s(%s::NullVal),\n", functionName, enumType);
+        indent(sb, level + 1, "}\n");
+        indent(sb, level, "}\n\n");
+    }
+
     private static void generateBitSetEncoder(
         final StringBuilder sb,
         final int level,
@@ -1341,7 +1381,7 @@ private static void generateSingleBitSet(
     static void appendImplEncoderTrait(
         final Appendable out,
         final String typeName,
-        final List<String> optionalPrimitiveFields) throws IOException
+        final List<String> optionalFields) throws IOException
     {
         indent(out, 1, "impl<%s> %s for %s {\n", BUF_LIFETIME, withBufLifetime("Writer"), withBufLifetime(typeName));
         indent(out, 2, "#[inline]\n");
@@ -1361,13 +1401,13 @@ static void appendImplEncoderTrait(
         indent(out, 3, "self.limit = limit;\n");
         indent(out, 2, "}\n");
 
-        if (!optionalPrimitiveFields.isEmpty())
+        if (!optionalFields.isEmpty())
         {
             indent(out, 0, "\n");
-            indent(out, 2, "/// Set all optional primitive scalar fields to their 'null' values.\n");
+            indent(out, 2, "/// Set all optional fields to their 'null' values.\n");
             indent(out, 2, "#[inline]\n");
             indent(out, 2, "fn nullify_optional_fields(&mut self) -> &mut Self {\n");
-            for (final String field : optionalPrimitiveFields)
+            for (final String field : optionalFields)
             {
                 indent(out, 3, "self.%s_opt(None);\n", field);
             }
@@ -1646,7 +1686,7 @@ static void appendImplEncoderForComposite(
         final Appendable out,
         final int level,
         final String name,
-        final List<String> optionalPrimitiveFields) throws IOException
+        final List<String> optionalFields) throws IOException
     {
         appendImplWriterForComposite(out, level, name);
 
@@ -1662,13 +1702,13 @@ static void appendImplEncoderForComposite(
         indent(out, level + 2, "self.parent.as_mut().expect(\"parent missing\").set_limit(limit);\n");
         indent(out, level + 1, "}\n");
 
-        if (!optionalPrimitiveFields.isEmpty())
+        if (!optionalFields.isEmpty())
         {
             indent(out, 0, "\n");
-            indent(out, 2, "/// Set all optional primitive scalar fields to their 'null' values.\n");
+            indent(out, 2, "/// Set all optional fields to their 'null' values.\n");
             indent(out, 2, "#[inline]\n");
             indent(out, 2, "fn nullify_optional_fields(&mut self) -> &mut Self {\n");
-            for (final String field : optionalPrimitiveFields)
+            for (final String field : optionalFields)
             {
                 indent(out, 3, "self.%s_opt(None);\n", field);
             }
@@ -1760,7 +1800,7 @@ private static void generateCompositeEncoder(
         indent(out, 3, "self.parent.take().ok_or(SbeErr::ParentNotSet)\n");
         indent(out, 2, "}\n\n");
 
-        final List<String> optionalPrimitiveFields = new ArrayList<>();
+        final List<String> optionalFields = new ArrayList<>();
         for (int i = 1, end = tokens.size() - 1; i < end; )
         {
             final Token encodingToken = tokens.get(i);
@@ -1774,11 +1814,16 @@ private static void generateCompositeEncoder(
                     {
                         generateOptionalPrimitiveEncoder(sb, 2, encodingToken, encodingToken.name(),
                             encodingToken.encoding());
-                        optionalPrimitiveFields.add(formatFunctionName(encodingToken.name()));
+                        optionalFields.add(formatFunctionName(encodingToken.name()));
                     }
                     break;
                 case BEGIN_ENUM:
                     generateEnumEncoder(sb, 2, encodingToken, encodingToken, encodingToken.name());
+                    if (isOptionalEnum(encodingToken, encodingToken))
+                    {
+                        generateOptionalEnumEncoder(sb, 2, encodingToken, encodingToken.name());
+                        optionalFields.add(formatFunctionName(encodingToken.name()));
+                    }
                     break;
                 case BEGIN_SET:
                     generateBitSetEncoder(sb, 2, encodingToken, encodingToken.name());
@@ -1794,7 +1839,7 @@ private static void generateCompositeEncoder(
             i += encodingToken.componentTokenCount();
         }
 
-        generateNullifyOptionalFieldsMethod(out, 2, optionalPrimitiveFields);
+        generateNullifyOptionalFieldsMethod(out, 2, optionalFields);
         indent(out, 1, "}\n"); // end impl
         indent(out, 0, "} // end encoder mod \n");
     }
diff --git a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/SubGroup.java b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/SubGroup.java
@@ -72,8 +72,8 @@ void generateEncoder(
         indent(sb, level, "initial_limit: usize,\n");
         indent(sb, level - 1, "}\n\n");
 
-        final List<String> optionalPrimitiveFields = RustGenerator.getOptionalPrimitiveFields(fields);
-        RustGenerator.appendImplEncoderForComposite(sb, level - 1, name, optionalPrimitiveFields);
+        final List<String> optionalFields = RustGenerator.getNullifyOptionalFields(fields);
+        RustGenerator.appendImplEncoderForComposite(sb, level - 1, name, optionalFields);
 
         // define impl...
         indent(sb, level - 1, "impl<'a, P> %s<P> where P: Encoder<'a> + Default {\n", name);
diff --git a/sbe-tool/src/test/resources/optional_enum_nullify.xml b/sbe-tool/src/test/resources/optional_enum_nullify.xml

Original file line number	Diff line number	Diff line change
`@@ -72,8 +72,8 @@ void generate(`
`72`	`72`
`73`	`73`	`if (codecType == Encoder)`
`74`	`74`	`{`
`75`		`- final List<String> optionalPrimitiveFields = RustGenerator.getOptionalPrimitiveFields(fields);`
`76`		`- RustGenerator.appendImplEncoderTrait(sb, msgTypeName, optionalPrimitiveFields);`
	`75`	`+ final List<String> optionalFields = RustGenerator.getNullifyOptionalFields(fields);`
	`76`	`+ RustGenerator.appendImplEncoderTrait(sb, msgTypeName, optionalFields);`
`77`	`77`	`}`
`78`	`78`	`else`
`79`	`79`	`{`