fix(starknet): handle empty enum in Store derive - #10069

• fix(starknet): handle empty enum in Store derive #10069 👈 (View in Graphite)
• main

This stack of pull requests is managed by Graphite. Learn more about stacking.

This change is 

PR Summary

Low Risk
Compiler plugin output fix for macro-generated storage code; behavior change is limited to previously broken empty enums and corrected match syntax for all enum derives.

Overview
Fixes #[derive(starknet::Store)] code generation for enums in handle_enum (store.rs).

Empty enums (enum Foo {}): when there are no variants, the macro now emits a dedicated impl instead of building variant matches. Read / read_at_offset return SyscallResult::Err with 'Read of an uninhabited type'; write / write_at_offset use empty match value {}; size() returns 0 (avoiding invalid 1_u8 + with no payload term).

Non-empty enums: match arms for read/write now carry their own trailing comma, and arms are joined with \n only (not ,\n), so generated match expressions are valid Cairo—including a comma after the last variant arm before the 0 | _ / _ catch-all.

Plugin snapshots (new_storage_interface, user_defined_types) add EmptyEnum and update expected enum Store output (trailing commas on write arms).

^{Reviewed by Cursor Bugbot for commit c879cdc. Bugbot is set up for automated code reviews on this repo. Configure here.}

The empty-enum handling can be a lot smaller. For a variant-less enum the existing template only breaks in two spots, and the comma fix already covers one of them:

1. size() emits a dangling 1_u8 + — the exact case the struct handler already guards one function up (if sizes.is_empty() { "0" }). A 3-line fallback after the loop is enough:

   if match_size.is_empty() {
       match_size = "0".to_string();
   }

   → 1_u8 + 0.
2. match idx { , 0 | _ => … } leading comma — already handled by moving the trailing comma into each arm (the comma fix in this PR).

With just those, the existing template generates valid code for empty enums:

fn read(...)  { let idx = Store::<felt252>::read(...)?; match idx { 0 | _ => Err(...) } }
fn write(..., value) { match value {}; Ok(()) }   // uninhabited → exhaustive
fn size() -> u8 { 1_u8 + 0 }

so the separate ~35-line impl isn't needed. Net is +16/−10 in store.rs instead of +45/−10, verified compiling via the golden test (EmptyEnum gets only the usual "no default variant" warning, no error).

Minor: this reuses the normal read (one extra felt read before erroring) and size is 1 not 0 — both moot for an uninhabited type, and 1 is arguably more consistent since every enum reserves the discriminant byte.

If we'd rather not pretend an uninhabited type is storable, the even-smaller option is to reject it outright with a diagnostic at the top of handle_enum and return None.