fix(per): encode empty extension addition group as absent per X.691 §… (#543)

* fix(per): encode empty extension addition group as absent per X.691 §19.9

* style: fix rustfmt formatting

* ci: trigger actions

* fix(per/tests): fix clippy warnings in issue505 test

Author: Abel981

macros/macros_impl/src/encode.rs

@@ -51,9 +51,11 @@ pub fn derive_struct_impl(
 
         if config.tag.as_ref().is_some_and(|tag| tag.is_explicit()) {
             // Note: encoder must be aware if the field is optional and present, so we should not do the presence check on this level
-            quote!(encoder
-                .encode_explicit_prefix(tag, &self.0, identifier.or(Self::IDENTIFIER))
-                .map(drop))
+            quote!(
+                encoder
+                    .encode_explicit_prefix(tag, &self.0, identifier.or(Self::IDENTIFIER))
+                    .map(drop)
+            )
         } else {
             // NOTE: AsnType trait already implements correct delegate constraints, and those are passed here
             // We don't need to do double intersection here!

src/per/enc.rs

@@ -1344,10 +1344,25 @@ impl<const RFC: usize, const EFC: usize> crate::Encoder<'_> for Encoder<RFC, EFC
         encoder.is_extension_sequence = true;
         encoder.number_optional_default_fields = E::FIELDS.number_of_optional_and_default_fields();
         value.encode(&mut encoder)?;
-        let output = encoder.output();
+        let out = encoder.output();
 
-        self.extension_fields[self.extension_bitfield.0] = Some(output);
-        self.set_extension_presence(true);
+        let all_absent = if E::FIELDS.has_required_field() {
+            false
+        } else if encoder.root_bitfield.0 > 0 {
+            encoder.root_bitfield.1[..encoder.root_bitfield.0]
+                .iter()
+                .all(|(present, _)| !present)
+        } else {
+            out.iter().all(|&b| b == 0)
+        };
+
+        if all_absent {
+            self.extension_fields[self.extension_bitfield.0] = None;
+            self.set_extension_presence(false);
+        } else {
+            self.extension_fields[self.extension_bitfield.0] = Some(out);
+            self.set_extension_presence(true);
+        }
         Ok(())
     }
 }

tests/issue505.rs

@@ -0,0 +1,76 @@
+use rasn::prelude::*;
+
+#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq)]
+#[rasn(tag(0))]
+pub struct S1ExtGroupB2 {
+    pub b2: Option<bool>,
+}
+
+#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq)]
+#[rasn(tag(1))]
+pub struct S1ExtGroupB3 {
+    pub b3: Option<bool>,
+}
+
+#[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq)]
+#[non_exhaustive]
+pub struct S1 {
+    pub b1: bool,
+    #[rasn(extension_addition_group)]
+    pub ext_group_b2: Option<S1ExtGroupB2>,
+    #[rasn(extension_addition_group)]
+    pub ext_group_b3: Option<S1ExtGroupB3>,
+}
+
+#[test]
+fn uper_issue505_empty_extension_group_encoded_as_absent() {
+    let value_with_empty_some = S1 {
+        b1: true,
+        ext_group_b2: Some(S1ExtGroupB2 { b2: None }),
+        ext_group_b3: Some(S1ExtGroupB3 { b3: Some(true) }),
+    };
+    let value_with_none = S1 {
+        b1: true,
+        ext_group_b2: None,
+        ext_group_b3: Some(S1ExtGroupB3 { b3: Some(true) }),
+    };
+
+    let enc_empty_some =
+        rasn::uper::encode(&value_with_empty_some).expect("encode Some({all None}) failed");
+    let enc_none = rasn::uper::encode(&value_with_none).expect("encode None failed");
+
+    assert_eq!(
+        enc_empty_some, enc_none,
+        "issue #505: Some({{all None}}) encoded as {:02X?} but None encoded as {:02X?} — \
+         empty extension group must be treated as absent per X.691 §19.9",
+        enc_empty_some, enc_none
+    );
+
+    let decoded: S1 = rasn::uper::decode(&enc_none).expect("decode failed");
+    assert!(decoded.b1);
+    assert_eq!(decoded.ext_group_b3, Some(S1ExtGroupB3 { b3: Some(true) }));
+}
+
+#[test]
+fn uper_issue505_some_all_none_equals_none() {
+    let with_empty_some = S1 {
+        b1: true,
+        ext_group_b2: Some(S1ExtGroupB2 { b2: None }),
+        ext_group_b3: None,
+    };
+    let with_none = S1 {
+        b1: true,
+        ext_group_b2: None,
+        ext_group_b3: None,
+    };
+
+    let enc_some = rasn::uper::encode(&with_empty_some).expect("encode failed");
+    let enc_none = rasn::uper::encode(&with_none).expect("encode failed");
+
+    assert_eq!(
+        enc_some, enc_none,
+        "Some({{all None}}) must encode identically to None per X.691 §19.9, \
+         got {:02X?} vs {:02X?}",
+        enc_some, enc_none
+    );
+}