Restructured type inference lattice and fixed issues in type analysis

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: fegge

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "masm-decompiler"
-version = "0.6.0"
+version = "0.6.1"
 edition = "2024"
 
 [dependencies]

src/decompile.rs

@@ -239,8 +239,8 @@ impl DecompiledProc {
             })
             .unwrap_or_else(|| {
                 (
-                    vec![TypeRequirement::Unknown; inputs],
-                    vec![InferredType::Unknown; outputs],
+                    vec![TypeRequirement::Felt; inputs],
+                    vec![InferredType::Felt; outputs],
                 )
             });
 
@@ -263,7 +263,7 @@ impl DecompiledProc {
 
 /// Normalize inferred input types to exactly match the known input arity.
 fn normalized_input_types(types: &[TypeRequirement], expected_len: usize) -> Vec<TypeRequirement> {
-    let mut normalized = vec![TypeRequirement::Unknown; expected_len];
+    let mut normalized = vec![TypeRequirement::Felt; expected_len];
     for (display_idx, slot) in normalized.iter_mut().enumerate() {
         let summary_idx = expected_len.saturating_sub(1).saturating_sub(display_idx);
         if let Some(ty) = types.get(summary_idx) {
@@ -275,7 +275,7 @@ fn normalized_input_types(types: &[TypeRequirement], expected_len: usize) -> Vec
 
 /// Normalize inferred output types to exactly match the known output arity.
 fn normalized_output_types(types: &[InferredType], expected_len: usize) -> Vec<InferredType> {
-    let mut normalized = vec![InferredType::Unknown; expected_len];
+    let mut normalized = vec![InferredType::Felt; expected_len];
     for (display_idx, slot) in normalized.iter_mut().enumerate() {
         let summary_idx = expected_len.saturating_sub(1).saturating_sub(display_idx);
         if let Some(ty) = types.get(summary_idx) {

src/fmt/mod.rs

@@ -730,7 +730,7 @@ impl CodeDisplay for DecompiledHeader {
                 .input_types
                 .get(i)
                 .copied()
-                .unwrap_or(TypeRequirement::Unknown);
+                .unwrap_or(TypeRequirement::Felt);
             args.push(format!(
                 "{}: {}",
                 f.fmt_var(&v),
@@ -747,7 +747,7 @@ impl CodeDisplay for DecompiledHeader {
                     .output_types
                     .first()
                     .copied()
-                    .unwrap_or(InferredType::Unknown);
+                    .unwrap_or(InferredType::Felt);
                 format!(" -> {}", type_name(inferred_type_for_display(ty)))
             }
             n => {
@@ -757,7 +757,7 @@ impl CodeDisplay for DecompiledHeader {
                             .output_types
                             .get(idx)
                             .copied()
-                            .unwrap_or(InferredType::Unknown);
+                            .unwrap_or(InferredType::Felt);
                         type_name(inferred_type_for_display(ty))
                     })
                     .collect::<Vec<_>>()
@@ -777,23 +777,19 @@ impl CodeDisplay for DecompiledHeader {
 }
 
 /// Convert an input type requirement to its formatter display string.
-///
-/// Unknown requirements are rendered as `Felt`.
 fn type_requirement_for_display(requirement: TypeRequirement) -> &'static str {
     match requirement {
-        TypeRequirement::Unknown | TypeRequirement::Felt => "Felt",
+        TypeRequirement::Felt => "Felt",
         TypeRequirement::Bool => "Bool",
         TypeRequirement::U32 => "U32",
         TypeRequirement::Address => "Address",
     }
 }
 
 /// Convert an inferred output type to its formatter display string.
-///
-/// Unknown inferred outputs are rendered as `Felt`.
 fn inferred_type_for_display(ty: InferredType) -> &'static str {
     match ty {
-        InferredType::Unknown | InferredType::Felt => "Felt",
+        InferredType::Felt => "Felt",
         InferredType::Bool => "Bool",
         InferredType::U32 => "U32",
         InferredType::Address => "Address",