lanl · bertschinger · Jun 22, 2026 · Jun 16, 2026
diff --git a/tests/no_alloc/tests/arrays.rs b/tests/no_alloc/tests/arrays.rs
@@ -15,13 +15,16 @@ fn fixed_length_byte_arrays() {
         d: [1u8, 0u8, 3u8, 4u8],
     };
 
+    assert_eq!(before.get_width(), 16);
+
     let mut bytes = vec![1; 16];
 
     assert_eq!(16, before.serialize(&mut bytes));
 
     let mut after = FixedOpaqueArrays::default();
 
     after.deserialize(&mut bytes.as_slice()).unwrap();
+    assert_eq!(after.get_width(), 16);
 
     assert_eq!(before, after);
 }
@@ -35,6 +38,7 @@ fn limited_length_byte_arrays() {
         d: vec![5u8, 6u8],
         e: vec![6u8, 7u8, 8u8, 9u8],
     };
+    assert_eq!(before.get_width(), 36);
 
     let mut bytes = vec![1; 36];
 
@@ -43,6 +47,7 @@ fn limited_length_byte_arrays() {
     let mut after = LimitedOpaqueArrays::default();
 
     after.deserialize(&mut bytes.as_slice()).unwrap();
+    assert_eq!(after.get_width(), 36);
 
     assert_eq!(before, after);
 }
@@ -57,6 +62,7 @@ fn limited_length_array_exceeded() {
         d: vec![],
         e: vec![],
     };
+    assert_eq!(before.get_width(), 40);
 
     let mut bytes = vec![0; 36];
 
@@ -66,13 +72,15 @@ fn limited_length_array_exceeded() {
 #[test]
 fn unlimited_byte_array() {
     let before = UnlimitedOpaqueArray { data: vec![7; 499] };
+    assert_eq!(before.get_width(), 504);
 
     let mut bytes = vec![1u8; 504];
 
     assert_eq!(504, before.serialize(&mut bytes));
 
     let mut after = UnlimitedOpaqueArray::default();
     after.deserialize(&mut bytes.as_slice()).unwrap();
+    assert_eq!(after.get_width(), 504);
 
     assert_eq!(before, after);
 }
@@ -83,12 +91,14 @@ fn strings() {
         str: "hello".into(),
         str_2: "world!!!".into(),
     };
+    assert_eq!(before.get_width(), 24);
 
     let mut bytes = vec![1u8; 24];
     assert_eq!(24, before.serialize(&mut bytes));
 
     let mut after = Strings::default();
     after.deserialize(&mut bytes.as_slice()).unwrap();
+    assert_eq!(after.get_width(), 24);
 
     assert_eq!(before, after);
 }
@@ -100,6 +110,7 @@ fn limited_length_string_exceeded() {
         str: "hello, world!".into(),
         str_2: "".into(),
     };
+    assert_eq!(before.get_width(), 24);
 
     let mut bytes = vec![0; 36];
 
@@ -122,6 +133,7 @@ fn arrays_of_user_defined_type() {
             a: u32::MAX - i as u32,
         });
     }
+    assert_eq!(before.get_width(), 2100);
 
     let mut bytes = [1; 2100];
 
@@ -130,6 +142,7 @@ fn arrays_of_user_defined_type() {
     let mut after = IntArrays::default();
 
     after.deserialize(&mut bytes.as_slice()).unwrap();
+    assert_eq!(after.get_width(), 2100);
 
     assert_eq!(before, after);
 }
@@ -141,6 +154,7 @@ fn too_long_array_of_user_defined_type() {
     for i in 0..8 {
         before.limited.push(AnInt { a: i });
     }
+    assert_eq!(before.get_width(), 16 + 36 + 4);
 
     let mut bytes = [1; 2100];
 

diff --git a/tests/no_alloc/tests/basic_structs.rs b/tests/no_alloc/tests/basic_structs.rs
@@ -15,11 +15,14 @@ fn struct_with_primitive_types() {
         d: (u32::MAX as u64) + 1,
     };
 
+    assert_eq!(before.get_width(), 24);
+
     let mut bytes = vec![0; 24];
 
     assert_eq!(24, before.serialize(&mut bytes));
 
     let mut after = Simple::default();
+    assert_eq!(after.get_width(), 24);
 
     after.deserialize(&mut bytes.as_slice()).unwrap();
 
@@ -36,6 +39,8 @@ fn buf_too_small() {
         d: (u32::MAX as u64) + 1,
     };
 
+    assert_eq!(before.get_width(), 24);
+
     let mut bytes = vec![0; 23];
 
     let _ = before.serialize(&mut bytes);
@@ -59,11 +64,14 @@ fn struct_with_inner_struct() {
         },
     };
 
+    assert_eq!(before.get_width(), 52);
+
     let mut bytes = vec![0; 52];
 
     assert_eq!(52, before.serialize(&mut bytes));
 
     let mut after = Container::default();
+    assert_eq!(after.get_width(), 52);
 
     after.deserialize(&mut bytes.as_slice()).unwrap();
 
@@ -73,12 +81,14 @@ fn struct_with_inner_struct() {
 #[test]
 fn struct_with_typedef() {
     let before = HasTypedef { blah: -12345 };
+    assert_eq!(before.get_width(), 4);
 
     let mut bytes = vec![0; 4];
 
     assert_eq!(4, before.serialize(&mut bytes));
 
     let mut after = HasTypedef::default();
+    assert_eq!(after.get_width(), 4);
 
     after.deserialize(&mut bytes.as_slice()).unwrap();
 

diff --git a/tests/no_alloc/tests/optionals.rs b/tests/no_alloc/tests/optionals.rs
@@ -13,21 +13,30 @@ fn recursive_optional() {
         let node = ListNode { data: i };
         before.list.push(node);
     }
+    assert_eq!(before.get_width(), 44);
 
     let mut bytes = vec![1; 44];
     assert_eq!(44, before.serialize(&mut bytes));
+
     let mut after = ListBegin::default();
+
     after.deserialize(&mut bytes.as_slice()).unwrap();
+    assert_eq!(44, after.get_width());
+
     assert_eq!(before, after);
 }
 
 #[test]
 fn non_recursive_optional_none() {
     let before = JustAnOption { maybe: None };
+    assert_eq!(before.get_width(), 4);
 
     let mut bytes = vec![1; 4];
     assert_eq!(4, before.serialize(&mut bytes));
+
     let mut after = JustAnOption::default();
+    assert_eq!(after.get_width(), 4);
+
     after.deserialize(&mut bytes.as_slice()).unwrap();
     assert_eq!(before, after);
 }
@@ -40,11 +49,15 @@ fn non_recursive_optional_some() {
             str: "Hello, world!".into(),
         }),
     };
+    assert_eq!(before.get_width(), 28);
 
     let mut bytes = vec![1; 28];
     assert_eq!(28, before.serialize(&mut bytes));
+
     let mut after = JustAnOption::default();
     after.deserialize(&mut bytes.as_slice()).unwrap();
+    assert_eq!(after.get_width(), 28);
+
     assert_eq!(before, after);
 }
 
@@ -64,10 +77,14 @@ fn mount_proto_export_list() {
         }
         before.inner.push(export);
     }
+    assert_eq!(before.get_width(), 504);
 
     let mut bytes = vec![1; 1024];
     assert_eq!(504, before.serialize(&mut bytes));
+
     let mut after = exports::default();
     after.deserialize(&mut bytes.as_slice()).unwrap();
+    assert_eq!(after.get_width(), 504);
+
     assert_eq!(before, after);
 }
diff --git a/tests/no_alloc/tests/unions.rs b/tests/no_alloc/tests/unions.rs
@@ -8,21 +8,25 @@ use unions::*;
 fn bool_union() {
     // True case:
     let before = MyOption { inner: Some(7) };
+    assert_eq!(before.get_width(), 8);
 
     let mut bytes = vec![1; 8];
     assert_eq!(8, before.serialize(&mut bytes));
 
     let mut after = MyOption::default();
 
     after.deserialize(&mut bytes.as_slice()).unwrap();
+    assert_eq!(after.get_width(), 8);
     assert_eq!(before, after);
 
     // False case:
     let before = MyOption { inner: None };
 
+    assert_eq!(4, before.get_width());
     assert_eq!(4, before.serialize(&mut bytes));
 
     after.deserialize(&mut bytes.as_slice()).unwrap();
+    assert_eq!(4, after.get_width());
     assert_eq!(before, after);
 }
 
@@ -46,42 +50,52 @@ fn invalid_enum_variant() {
 #[test]
 fn enum_union_no_default() {
     let before = Stuff::one(99);
+    assert_eq!(before.get_width(), 8);
     let mut bytes = [1; 100];
     assert_eq!(8, before.serialize(&mut bytes));
     let mut after = Stuff::default();
     after.deserialize(&mut bytes.as_slice()).unwrap();
+    assert_eq!(after.get_width(), 8);
     assert_eq!(before, after);
 
     let before = Stuff::two(MyOption {
         inner: Some(i32::MAX),
     });
+    assert_eq!(before.get_width(), 12);
     assert_eq!(12, before.serialize(&mut bytes));
     after.deserialize(&mut bytes.as_slice()).unwrap();
+    assert_eq!(after.get_width(), 12);
     assert_eq!(before, after);
 
     let before = Stuff::three;
+    assert_eq!(before.get_width(), 4);
     assert_eq!(4, before.serialize(&mut bytes));
     after.deserialize(&mut bytes.as_slice()).unwrap();
+    assert_eq!(after.get_width(), 4);
     assert_eq!(before, after);
 }
 
 #[test]
 fn enum_union_default_void() {
     let before = Things::Default;
     let mut bytes = [1; 4];
+    assert_eq!(before.get_width(), 4);
     assert_eq!(4, before.serialize(&mut bytes));
     let mut after = Things::default();
     after.deserialize(&mut bytes.as_slice()).unwrap();
+    assert_eq!(after.get_width(), 4);
     assert_eq!(before, after);
 }
 
 #[test]
 fn enum_union_default_non_void() {
     let before = MoreThings::Default(7);
     let mut bytes = [1; 8];
+    assert_eq!(before.get_width(), 8);
     assert_eq!(8, before.serialize(&mut bytes));
     let mut after = MoreThings::default();
     after.deserialize(&mut bytes.as_slice()).unwrap();
+    assert_eq!(after.get_width(), 8);
     assert_eq!(before, after);
 }
 

diff --git a/xdr_codegen/src/codegen/deserialize.rs b/xdr_codegen/src/codegen/deserialize.rs
@@ -164,30 +164,18 @@ impl ValidatedUnionEnumBody {
 
 impl ValidatedStruct {
     pub fn offset_to_string(off: &DeclarationOfset) -> String {
-        let code = off
-            .deps
-            .iter()
-            .map(|v| format!("self.get_{}_width()?", v))
-            .chain(
-                vec![format!("{}", off.known)]
-                    .into_iter()
-                    .filter(|v| v != "0"),
-            )
-            .collect::<Vec<String>>()
-            .join(" + ");
+        Self::offset_to_string_with_unwrapper(off, "?")
+    }
 
-        if code.is_empty() {
-            "0".to_string()
-        } else {
-            code.clone()
-        }
+    pub fn offset_to_string_infallible(off: &DeclarationOfset) -> String {
+        Self::offset_to_string_with_unwrapper(off, ".unwrap()")
     }
 
-    pub fn offset_to_string_localvars(off: &DeclarationOfset) -> String {
+    pub fn offset_to_string_with_unwrapper(off: &DeclarationOfset, unwrapper: &str) -> String {
         let code = off
             .deps
             .iter()
-            .map(|v| format!("{}_width", v))
+            .map(|v| format!("self.get_{}_width(){}", v, unwrapper))
             .chain(
                 vec![format!("{}", off.known)]
                     .into_iter()
@@ -203,11 +191,11 @@ impl ValidatedStruct {
         }
     }
 
-    pub fn offset_to_string_infallible(off: &DeclarationOfset) -> String {
+    pub fn offset_to_string_localvars(off: &DeclarationOfset) -> String {
         let code = off
             .deps
             .iter()
-            .map(|v| format!("self.get_{}_width().unwrap()", v))
+            .map(|v| format!("{}_width", v))
             .chain(
                 vec![format!("{}", off.known)]
                     .into_iter()