From 889c0c71222021c7a7c2dec6c5b0209001c01d4a Mon Sep 17 00:00:00 2001
From: piotmag769 <piotrmagiera150@gmail.com>
Date: Mon, 15 Jun 2026 17:23:32 +0200
Subject: [PATCH] Display array types

commit-id:bd01fe53
---
 src/debugger/state/call_stack.rs           |  8 +--
 src/debugger/state/call_stack/variables.rs | 62 ++++++++++++++++++++--
 2 files changed, 63 insertions(+), 7 deletions(-)

diff --git a/src/debugger/state/call_stack.rs b/src/debugger/state/call_stack.rs
index a3cc44d..ac2b6aa 100644
--- a/src/debugger/state/call_stack.rs
+++ b/src/debugger/state/call_stack.rs
@@ -284,16 +284,16 @@ impl CallStack {
                     ..Default::default()
                 }
             }
-            CairoValue::Array { elements } => {
+            CairoValue::Array { element_type, elements } => {
+                let type_display = format!("Array<{element_type}>");
                 if elements.is_empty() {
                     Variable {
                         name,
-                        value: "[]".to_string(),
+                        value: type_display,
                         variables_reference: 0,
                         ..Default::default()
                     }
                 } else {
-                    let len = elements.len();
                     let children = elements
                         .into_iter()
                         .enumerate()
@@ -302,7 +302,7 @@ impl CallStack {
                     let ref_id = self.register_children(children);
                     Variable {
                         name,
-                        value: format!("[{len}]"),
+                        value: type_display,
                         variables_reference: ref_id,
                         ..Default::default()
                     }
diff --git a/src/debugger/state/call_stack/variables.rs b/src/debugger/state/call_stack/variables.rs
index 760329f..7445bb0 100644
--- a/src/debugger/state/call_stack/variables.rs
+++ b/src/debugger/state/call_stack/variables.rs
@@ -24,7 +24,7 @@ pub enum CairoValue {
     Struct { type_name: String, fields: Vec<(String, CairoValue)> },
     Enum { type_name: String, variant_name: String, variant_value: Box<CairoValue> },
     Tuple(Vec<CairoValue>),
-    Array { elements: Vec<CairoValue> },
+    Array { element_type: String, elements: Vec<CairoValue> },
     Snapshot(Box<CairoValue>),
     NonZero(Box<CairoValue>),
     Other(String),
@@ -282,6 +282,61 @@ fn extract_short_type_name(type_id: &ConcreteTypeId) -> String {
     format!("type_{}", type_id.id)
 }
 
+fn format_type_name(type_id: &ConcreteTypeId, ctx: &Context) -> String {
+    let Some(concrete_type) = ctx.get_concrete_type(type_id) else {
+        return extract_short_type_name(type_id);
+    };
+    match concrete_type {
+        CoreTypeConcrete::Array(info) => format!("Array<{}>", format_type_name(&info.ty, ctx)),
+        CoreTypeConcrete::Span(info) => format!("Span<{}>", format_type_name(&info.ty, ctx)),
+        CoreTypeConcrete::Snapshot(inner) => format!("@{}", format_type_name(&inner.ty, ctx)),
+        CoreTypeConcrete::NonZero(inner) => {
+            format!("NonZero<{}>", format_type_name(&inner.ty, ctx))
+        }
+        CoreTypeConcrete::Nullable(inner) => {
+            format!("Nullable<{}>", format_type_name(&inner.ty, ctx))
+        }
+        CoreTypeConcrete::Felt252(_) => "felt252".to_string(),
+        CoreTypeConcrete::Uint8(_) => "u8".to_string(),
+        CoreTypeConcrete::Uint16(_) => "u16".to_string(),
+        CoreTypeConcrete::Uint32(_) => "u32".to_string(),
+        CoreTypeConcrete::Uint64(_) => "u64".to_string(),
+        CoreTypeConcrete::Uint128(_) => "u128".to_string(),
+        CoreTypeConcrete::Sint8(_) => "i8".to_string(),
+        CoreTypeConcrete::Sint16(_) => "i16".to_string(),
+        CoreTypeConcrete::Sint32(_) => "i32".to_string(),
+        CoreTypeConcrete::Sint64(_) => "i64".to_string(),
+        CoreTypeConcrete::Sint128(_) => "i128".to_string(),
+        CoreTypeConcrete::Bytes31(_) => "bytes31".to_string(),
+        CoreTypeConcrete::Struct(_) => {
+            let type_long_id = &ctx.var_type_info(type_id).long_id;
+            if is_tuple(type_long_id) {
+                return "Tuple".to_string();
+            }
+            ctx.struct_info(type_id)
+                .map(|info| info.name.clone())
+                .unwrap_or_else(|| extract_short_type_name(type_id))
+        }
+        CoreTypeConcrete::Enum(_) => {
+            let type_long_id = &ctx.var_type_info(type_id).long_id;
+            if is_bool(type_long_id) {
+                return "bool".to_string();
+            }
+            ctx.enum_info(type_id)
+                .map(|info| info.name.clone())
+                .unwrap_or_else(|| extract_short_type_name(type_id))
+        }
+        CoreTypeConcrete::Starknet(starknet_type) => match starknet_type {
+            StarknetTypeConcrete::ContractAddress(_) => "ContractAddress".to_string(),
+            StarknetTypeConcrete::ClassHash(_) => "ClassHash".to_string(),
+            StarknetTypeConcrete::StorageAddress(_) => "StorageAddress".to_string(),
+            StarknetTypeConcrete::StorageBaseAddress(_) => "StorageBaseAddress".to_string(),
+            _ => extract_short_type_name(type_id),
+        },
+        _ => extract_short_type_name(type_id),
+    }
+}
+
 fn is_tuple(type_long_id: &ConcreteTypeLongId) -> bool {
     type_long_id.generic_id.0 == "Struct"
         && matches!(
@@ -378,9 +433,10 @@ fn extract_array_from_pointers(
         return None;
     }
 
+    let element_type = format_type_name(element_type_id, ctx);
     let element_size = ctx.type_size(element_type_id);
     if element_size == 0 {
-        return Some(CairoValue::Array { elements: vec![] });
+        return Some(CairoValue::Array { element_type, elements: vec![] });
     }
 
     let total_cells = end_ptr.offset.checked_sub(start_ptr.offset)?;
@@ -412,7 +468,7 @@ fn extract_array_from_pointers(
         )?);
     }
 
-    Some(CairoValue::Array { elements })
+    Some(CairoValue::Array { element_type, elements })
 }
 
 fn maybe_get_felt_from_cell_ref(