Move wire size computation from parser to IR module

The wire size computation is only used by the IR builder, not by the
parser or Rust code generator. Moving it to ir.rs:

- Eliminates ComputedProperties/TypeProperties types (replaced by a
  plain HashMap internal to ir.rs)
- Exposes a single ir::build() entry point that takes &XdrSpec and
  returns IR (hides TypeInfo, wire size computation, const resolution)
- Collapses 13 lines of IR construction in main.rs to one call
- Moves wire size tests from parser to generator (where the code lives)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: tamirms

xdr-definitions-json/xdr.json

@@ -6,8 +6,9 @@
 //! values) embedded directly.
 
 use serde::Serialize;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use xdr_parser::ast;
+use xdr_parser::types::TypeInfo;
 
 /// Top-level IR output.
 #[derive(Serialize)]
@@ -147,12 +148,11 @@ pub enum TypeRef {
     },
 }
 
-/// Build IR definitions from the AST spec and computed properties.
-pub fn build_definitions(
-    spec: &ast::XdrSpec,
-    computed: &xdr_parser::types::ComputedProperties,
-) -> Vec<Definition> {
-    // Build enum member value lookup for resolving union case idents.
+/// Build the complete IR from a parsed (and optionally filtered) XDR spec.
+pub fn build(spec: &ast::XdrSpec, resolved_features: Vec<String>) -> IR {
+    let type_info = TypeInfo::build(spec, &|name| name.to_string());
+    let wire_sizes = compute_wire_sizes(&type_info);
+
     let mut enum_member_values: HashMap<&str, i32> = HashMap::new();
     for def in spec.all_definitions() {
         if let ast::Definition::Enum(e) = def {
@@ -162,21 +162,30 @@ pub fn build_definitions(
         }
     }
 
-    // Build const value lookup for resolving named sizes.
-    let const_values = &computed.const_values;
+    let const_values = &type_info.const_values;
+
+    let definitions = spec.all_definitions()
+        .map(|def| convert_definition(def, &wire_sizes, const_values, &enum_member_values))
+        .collect();
 
-    spec.all_definitions()
-        .map(|def| convert_definition(def, computed, const_values, &enum_member_values))
-        .collect()
+    IR {
+        version: 1,
+        files: spec.files.iter().map(|f| XdrFile {
+            name: f.name.clone(),
+            sha256: f.sha256.clone(),
+        }).collect(),
+        resolved_features,
+        definitions,
+    }
 }
 
 fn convert_definition(
     def: &ast::Definition,
-    computed: &xdr_parser::types::ComputedProperties,
+    wire_sizes: &HashMap<String, Option<u32>>,
     const_values: &HashMap<String, i64>,
     enum_member_values: &HashMap<&str, i32>,
 ) -> Definition {
-    let fixed_size = computed.types.get(def.name()).and_then(|p| p.fixed_wire_size);
+    let fixed_size = wire_sizes.get(def.name()).copied().flatten();
     match def {
         ast::Definition::Struct(s) => Definition::Struct(Struct {
             name: s.name.clone(),
@@ -293,3 +302,117 @@ fn resolve_size(size: &ast::Size, const_values: &HashMap<String, i64>) -> u64 {
         }
     }
 }
+
+// =============================================================================
+// Wire size computation
+// =============================================================================
+
+fn compute_wire_sizes(type_info: &TypeInfo) -> HashMap<String, Option<u32>> {
+    let mut cache: HashMap<String, Option<u32>> = HashMap::new();
+    let mut in_progress: HashSet<String> = HashSet::new();
+    for name in type_info.definitions.keys() {
+        compute_wire_size(type_info, name, &mut cache, &mut in_progress);
+    }
+    cache
+}
+
+fn compute_wire_size(
+    ti: &TypeInfo,
+    name: &str,
+    cache: &mut HashMap<String, Option<u32>>,
+    in_progress: &mut HashSet<String>,
+) -> Option<u32> {
+    if let Some(&cached) = cache.get(name) {
+        return cached;
+    }
+    if in_progress.contains(name) {
+        return None;
+    }
+    in_progress.insert(name.to_string());
+
+    let result = match ti.definitions.get(name) {
+        Some(ast::Definition::Struct(s)) => {
+            let mut total: u32 = 0;
+            for member in &s.members {
+                match type_wire_size(ti, &member.type_, cache, in_progress) {
+                    Some(sz) => {
+                        total = match total.checked_add(sz) {
+                            Some(t) => t,
+                            None => {
+                                in_progress.remove(name);
+                                cache.insert(name.to_string(), None);
+                                return None;
+                            }
+                        };
+                    }
+                    None => {
+                        in_progress.remove(name);
+                        cache.insert(name.to_string(), None);
+                        return None;
+                    }
+                }
+            }
+            Some(total)
+        }
+        Some(ast::Definition::Union(u)) => {
+            let disc_size: u32 = 4;
+            let mut arm_sizes: Vec<Option<u32>> = Vec::new();
+            for arm in &u.arms {
+                match &arm.type_ {
+                    None => arm_sizes.push(Some(0)),
+                    Some(t) => arm_sizes.push(type_wire_size(ti, t, cache, in_progress)),
+                }
+            }
+            if arm_sizes.is_empty()
+                || arm_sizes.iter().any(|s| s.is_none())
+                || arm_sizes.iter().filter_map(|s| *s).collect::<HashSet<_>>().len() != 1
+            {
+                None
+            } else {
+                disc_size.checked_add(arm_sizes[0]?)
+            }
+        }
+        Some(ast::Definition::Enum(_)) => Some(4),
+        Some(ast::Definition::Typedef(t)) => type_wire_size(ti, &t.type_, cache, in_progress),
+        Some(ast::Definition::Const(_)) | None => None,
+    };
+
+    in_progress.remove(name);
+    cache.insert(name.to_string(), result);
+    result
+}
+
+fn type_wire_size(
+    ti: &TypeInfo,
+    type_: &ast::Type,
+    cache: &mut HashMap<String, Option<u32>>,
+    in_progress: &mut HashSet<String>,
+) -> Option<u32> {
+    match type_ {
+        ast::Type::Int | ast::Type::UnsignedInt | ast::Type::Bool | ast::Type::Float => Some(4),
+        ast::Type::Hyper | ast::Type::UnsignedHyper | ast::Type::Double => Some(8),
+        ast::Type::OpaqueFixed(size) => {
+            let sz = resolve_size_u32(ti, size)?;
+            sz.checked_add(3).map(|v| v & !3)
+        }
+        ast::Type::Array { element_type, size } => {
+            let elem_sz = type_wire_size(ti, element_type, cache, in_progress)?;
+            let count = resolve_size_u32(ti, size)?;
+            elem_sz.checked_mul(count)
+        }
+        ast::Type::Ident(name) => compute_wire_size(ti, name, cache, in_progress),
+        ast::Type::OpaqueVar(_) | ast::Type::String(_) | ast::Type::VarArray { .. } | ast::Type::Optional(_) => {
+            None
+        }
+    }
+}
+
+fn resolve_size_u32(ti: &TypeInfo, size: &ast::Size) -> Option<u32> {
+    match size {
+        ast::Size::Literal(n) => Some(*n),
+        ast::Size::Named(name) => ti
+            .const_values
+            .get(name)
+            .and_then(|&v| u32::try_from(v).ok()),
+    }
+}

xdr-generator-rust/generator/src/ir.rs

@@ -93,19 +93,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             filter_spec(&mut ir_spec, &features);
         }
 
-        let type_info = xdr_parser::types::TypeInfo::build(&ir_spec, &|name| name.to_string());
-        let computed = type_info.compute_properties();
-        let definitions = ir::build_definitions(&ir_spec, &computed);
-
-        let output = ir::IR {
-            version: 1,
-            files: ir_spec.files.iter().map(|f| ir::XdrFile {
-                name: f.name.clone(),
-                sha256: f.sha256.clone(),
-            }).collect(),
-            resolved_features,
-            definitions,
-        };
+        let output = ir::build(&ir_spec, resolved_features);
         let json = serde_json::to_string_pretty(&output)?;
         fs::write(json_path, json)?;
         eprintln!(

xdr-generator-rust/generator/src/main.rs

@@ -2,3 +2,4 @@ mod cfg_filter;
 mod generator;
 mod naming;
 mod types;
+mod wire_size;

xdr-generator-rust/generator/src/tests/mod.rs

@@ -0,0 +1,112 @@
+use crate::ir;
+
+fn wire_sizes(input: &str) -> std::collections::HashMap<String, Option<u32>> {
+    let spec = xdr_parser::parser::parse(input).unwrap();
+    let ir = ir::build(&spec, Vec::new());
+    let mut sizes = std::collections::HashMap::new();
+    for def in &ir.definitions {
+        let (name, fixed_size) = match def {
+            ir::Definition::Struct(s) => (&s.name, s.fixed_size),
+            ir::Definition::Union(u) => (&u.name, u.fixed_size),
+            _ => continue,
+        };
+        sizes.insert(name.clone(), fixed_size);
+    }
+    sizes
+}
+
+#[test]
+fn test_fixed_wire_size() {
+    let input = r#"
+        struct Fixed { int x; unsigned hyper y; };
+        struct Variable { int x; opaque data<>; };
+    "#;
+    let sizes = wire_sizes(input);
+    assert_eq!(sizes["Fixed"], Some(12));
+    assert_eq!(sizes["Variable"], None);
+}
+
+#[test]
+fn test_union_fixed() {
+    let input = r#"
+        union U switch (int v) {
+            case 0: int a;
+            case 1: int b;
+        };
+    "#;
+    let sizes = wire_sizes(input);
+    assert_eq!(sizes["U"], Some(8));
+}
+
+#[test]
+fn test_union_variable() {
+    let input = r#"
+        union U switch (int v) {
+            case 0: int a;
+            case 1: opaque b<>;
+        };
+    "#;
+    let sizes = wire_sizes(input);
+    assert_eq!(sizes["U"], None);
+}
+
+#[test]
+fn test_union_different_arm_sizes() {
+    let input = r#"
+        union U switch (int v) {
+            case 0: int a;
+            case 1: hyper b;
+        };
+    "#;
+    let sizes = wire_sizes(input);
+    assert_eq!(sizes["U"], None);
+}
+
+#[test]
+fn test_opaque_padding() {
+    let input = "typedef opaque Hash[32];";
+    let ir = ir::build(&xdr_parser::parser::parse(input).unwrap(), Vec::new());
+    // Check via the TypeRef size on the typedef
+    if let ir::Definition::Typedef(t) = &ir.definitions[0] {
+        if let ir::TypeRef::OpaqueFixed { size } = &t.type_ {
+            assert_eq!(*size, 32);
+        } else {
+            panic!("expected OpaqueFixed");
+        }
+    }
+}
+
+#[test]
+fn test_opaque_padding_unaligned() {
+    let input = "typedef opaque ShortHash[3];";
+    let ir = ir::build(&xdr_parser::parser::parse(input).unwrap(), Vec::new());
+    if let ir::Definition::Typedef(t) = &ir.definitions[0] {
+        if let ir::TypeRef::OpaqueFixed { size } = &t.type_ {
+            assert_eq!(*size, 3); // raw size, consumer computes padding
+        } else {
+            panic!("expected OpaqueFixed");
+        }
+    }
+}
+
+#[test]
+fn test_fixed_array() {
+    let input = r#"
+        struct Pair { int a; int b; };
+        struct Container { Pair items[3]; };
+    "#;
+    let sizes = wire_sizes(input);
+    assert_eq!(sizes["Pair"], Some(8));
+    assert_eq!(sizes["Container"], Some(24));
+}
+
+#[test]
+fn test_typedef_chain() {
+    let input = r#"
+        typedef int MyInt;
+        typedef MyInt AnotherInt;
+        struct S { AnotherInt x; };
+    "#;
+    let sizes = wire_sizes(input);
+    assert_eq!(sizes["S"], Some(4));
+}