Generate Rust enum shells from spec literalUnions

This PR teaches the generator to emit Rust `enum` shells from spec `literalUnion` TypeExprs, parallel to the enumeration support added in the previous PR. The sole `literalUnion` in v1 is `isSigner: [true, false, "either"]`, referenced by `instructionAccountNode.isSigner` and `instructionRemainingAccountsNode.isSigner` (two value-identical inline copies); both consumers collapse to a single generated type. Because `literalUnion` is anonymous and inline in the spec — there's no name registry, unlike `enumerations` — the type name is derived from the referencing attribute (`pascalCase('isSigner')` → `IsSigner`). Distinct value-sets become distinct types; the same value-set referenced by two differently-named attributes throws as ambiguous.

The renderer uses a deliberately narrower derive set than `enumPage` does: `Debug, PartialEq, Eq, Clone, Copy` only — no `Serialize`/`Deserialize`, no `Default`, no `rename_all`. A `literalUnion`'s wire form is heterogeneous (real JSON booleans for the boolean variants, a string for the `"either"` case) and can't be expressed via serde's declarative attributes; the bespoke `Serialize`/`Deserialize` visitor pair, the `From<bool>` conversion, and the `Default` choice all stay hand-written in a companion file. This is the same generated-shell / hand-written-impls split established by `Number` and re-used for the enumeration `Default` impls in the previous PR.

Reconciling the Rust crate required one breaking rename: `IsAccountSigner → IsSigner`, since the generator derives the type name from the attribute name. ~45 occurrences across `codama-nodes` (2 node files + `shared/`) and `codama-attributes` (the `FromMeta` impl + `account_directive` tests). The hand-written `shared/is_account_signer.rs` (104 lines, enum + impls + tests) becomes `shared/is_signer.rs` (impls + tests only — 122 lines, +2 tests covering `From<bool>` and `default_is_false` that weren't previously covered). One small wiring note: `attributeBodyLine.ts` resolves the literalUnion field type itself (because `getTypeExprFragment` has no access to the attribute name), while `typeExpr.ts`'s `literalUnion` case continues to throw — only nested-position literalUnions would reach it, and those don't occur in v1.

Workspace-wide: 1006 → 1008 cargo tests passing (+2 from the new hand-written tests), 119 → 130 JS tests passing (+11 from the new discovery + renderer + integration tests), fmt and clippy stay clean, `pnpm generate` round-trips deterministically. The override surface (3 maps, `FIELD_TYPE_OVERRIDES` with 1 entry) is unchanged.

Author: lorisleiva

codama-attributes/src/codama_directives/account_directive.rs

@@ -4,15 +4,15 @@ use crate::{
 };
 use codama_errors::{CodamaError, CodamaResult};
 use codama_nodes::{
-    CamelCaseString, Docs, InstructionAccountNode, InstructionInputValueNode, IsAccountSigner,
+    CamelCaseString, Docs, InstructionAccountNode, InstructionInputValueNode, IsSigner,
 };
 use codama_syn_helpers::{extensions::*, Meta};
 
 #[derive(Debug, PartialEq)]
 pub struct AccountDirective {
     pub name: CamelCaseString,
     pub is_writable: bool,
-    pub is_signer: IsAccountSigner,
+    pub is_signer: IsSigner,
     pub is_optional: bool,
     pub docs: Docs,
     pub default_value: Option<Resolvable<InstructionInputValueNode>>,
@@ -29,7 +29,7 @@ impl AccountDirective {
             name = name.initial_value(ident.to_string().into())
         }
         let mut is_writable = SetOnce::<bool>::new("writable").initial_value(false);
-        let mut is_signer = SetOnce::<IsAccountSigner>::new("signer").initial_value(false.into());
+        let mut is_signer = SetOnce::<IsSigner>::new("signer").initial_value(false.into());
         let mut is_optional = SetOnce::<bool>::new("optional").initial_value(false);
         let mut default_value =
             SetOnce::<Resolvable<InstructionInputValueNode>>::new("default_value");
@@ -41,7 +41,7 @@ impl AccountDirective {
                 .each(|ref meta| match meta.path_str().as_str() {
                     "name" => name.set(meta.as_value()?.as_expr()?.as_string()?.into(), meta),
                     "writable" => is_writable.set(bool::from_meta(meta)?, meta),
-                    "signer" => is_signer.set(IsAccountSigner::from_meta(meta)?, meta),
+                    "signer" => is_signer.set(IsSigner::from_meta(meta)?, meta),
                     "optional" => is_optional.set(bool::from_meta(meta)?, meta),
                     "default_value" => default_value.set(
                         Resolvable::<InstructionInputValueNode>::from_meta(meta.as_value()?)?,
@@ -117,7 +117,7 @@ mod tests {
             AccountDirective {
                 name: "payer".into(),
                 is_writable: true,
-                is_signer: IsAccountSigner::True,
+                is_signer: IsSigner::True,
                 is_optional: true,
                 default_value: Some(Resolvable::Resolved(PayerValueNode::new().into())),
                 docs: Docs::default(),
@@ -142,7 +142,7 @@ mod tests {
             AccountDirective {
                 name: "payer".into(),
                 is_writable: true,
-                is_signer: IsAccountSigner::Either,
+                is_signer: IsSigner::Either,
                 is_optional: false,
                 default_value: Some(Resolvable::Resolved(PayerValueNode::new().into())),
                 docs: Docs::default(),
@@ -161,7 +161,7 @@ mod tests {
             AccountDirective {
                 name: "authority".into(),
                 is_writable: false,
-                is_signer: IsAccountSigner::False,
+                is_signer: IsSigner::False,
                 is_optional: false,
                 default_value: None,
                 docs: Docs::default(),
@@ -189,7 +189,7 @@ mod tests {
             AccountDirective {
                 name: "stake".into(),
                 is_writable: true,
-                is_signer: IsAccountSigner::False,
+                is_signer: IsSigner::False,
                 is_optional: false,
                 default_value: None,
                 docs: vec!["what this account is for".to_string()].into(),
@@ -208,7 +208,7 @@ mod tests {
             AccountDirective {
                 name: "authority".into(),
                 is_writable: false,
-                is_signer: IsAccountSigner::True,
+                is_signer: IsSigner::True,
                 is_optional: false,
                 default_value: None,
                 docs: vec![

codama-attributes/src/utils/from_meta.rs

@@ -1,4 +1,4 @@
-use codama_nodes::{BytesEncoding, Docs, IsAccountSigner, OptionalAccountStrategy};
+use codama_nodes::{BytesEncoding, Docs, IsSigner, OptionalAccountStrategy};
 use codama_syn_helpers::{extensions::*, Meta};
 use syn::Expr;
 
@@ -20,7 +20,7 @@ impl FromMeta for bool {
     }
 }
 
-impl FromMeta for IsAccountSigner {
+impl FromMeta for IsSigner {
     fn from_meta(meta: &Meta) -> syn::Result<Self> {
         if let Ok(value) = bool::from_meta(meta) {
             return Ok(value.into());

codama-nodes/src/generated/shared/is_signer.rs

@@ -0,0 +1,6 @@
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum IsSigner {
+    True,
+    False,
+    Either,
+}

codama-nodes/src/generated/shared/mod.rs

@@ -2,6 +2,7 @@ mod bytes_encoding;
 mod default_value_strategy;
 mod endianness;
 mod instruction_lifecycle;
+mod is_signer;
 mod number_format;
 mod optional_account_strategy;
 mod post_offset_strategy;
@@ -12,6 +13,7 @@ pub use bytes_encoding::*;
 pub use default_value_strategy::*;
 pub use endianness::*;
 pub use instruction_lifecycle::*;
+pub use is_signer::*;
 pub use number_format::*;
 pub use optional_account_strategy::*;
 pub use post_offset_strategy::*;

codama-nodes/src/instruction_account_node.rs

@@ -1,12 +1,12 @@
-use crate::{CamelCaseString, Docs, HasName, InstructionInputValueNode, IsAccountSigner};
+use crate::{CamelCaseString, Docs, HasName, InstructionInputValueNode, IsSigner};
 use codama_nodes_derive::node;
 
 #[node]
 pub struct InstructionAccountNode {
     // Data.
     pub name: CamelCaseString,
     pub is_writable: bool,
-    pub is_signer: IsAccountSigner,
+    pub is_signer: IsSigner,
     #[serde(default, skip_serializing_if = "crate::is_default")]
     pub is_optional: bool,
     #[serde(default, skip_serializing_if = "crate::is_default")]
@@ -21,7 +21,7 @@ impl InstructionAccountNode {
     pub fn new<T, U>(name: T, is_writable: bool, is_signer: U) -> Self
     where
         T: Into<CamelCaseString>,
-        U: Into<IsAccountSigner>,
+        U: Into<IsSigner>,
     {
         Self {
             name: name.into(),
@@ -50,7 +50,7 @@ mod tests {
         let node = InstructionAccountNode::new("my_account", false, true);
         assert_eq!(node.name, CamelCaseString::new("myAccount"));
         assert!(!node.is_writable);
-        assert_eq!(node.is_signer, IsAccountSigner::True);
+        assert_eq!(node.is_signer, IsSigner::True);
         assert!(!node.is_optional);
         assert_eq!(node.docs, Docs::default());
         assert_eq!(node.default_value, None);
@@ -61,14 +61,14 @@ mod tests {
         let node = InstructionAccountNode {
             name: "myAccount".into(),
             is_writable: false,
-            is_signer: IsAccountSigner::Either,
+            is_signer: IsSigner::Either,
             is_optional: true,
             docs: vec!["Hello".to_string()].into(),
             default_value: Some(AccountValueNode::new("myOtherAccount").into()),
         };
         assert_eq!(node.name, CamelCaseString::new("myAccount"));
         assert!(!node.is_writable);
-        assert_eq!(node.is_signer, IsAccountSigner::Either);
+        assert_eq!(node.is_signer, IsSigner::Either);
         assert!(node.is_optional);
         assert_eq!(*node.docs, vec!["Hello".to_string()]);
         assert_eq!(

codama-nodes/src/instruction_remaining_accounts_node.rs

@@ -1,4 +1,4 @@
-use crate::{ArgumentValueNode, Docs, IsAccountSigner, ResolverValueNode};
+use crate::{ArgumentValueNode, Docs, IsSigner, ResolverValueNode};
 use codama_nodes_derive::{node, node_union};
 
 #[node]
@@ -7,7 +7,7 @@ pub struct InstructionRemainingAccountsNode {
     #[serde(default, skip_serializing_if = "crate::is_default")]
     pub is_optional: bool,
     #[serde(default, skip_serializing_if = "crate::is_default")]
-    pub is_signer: IsAccountSigner,
+    pub is_signer: IsSigner,
     #[serde(default, skip_serializing_if = "crate::is_default")]
     pub is_writable: bool,
     #[serde(default, skip_serializing_if = "crate::is_default")]
@@ -31,13 +31,13 @@ mod tests {
     fn direct_instantiation() {
         let node = InstructionRemainingAccountsNode {
             is_optional: false,
-            is_signer: IsAccountSigner::Either,
+            is_signer: IsSigner::Either,
             is_writable: true,
             docs: vec!["This is a test".to_string()].into(),
             value: ArgumentValueNode::new("myArgument").into(),
         };
         assert!(!node.is_optional);
-        assert_eq!(node.is_signer, IsAccountSigner::Either);
+        assert_eq!(node.is_signer, IsSigner::Either);
         assert!(node.is_writable);
         assert_eq!(node.docs, vec!["This is a test".to_string()].into());
         assert_eq!(
@@ -50,7 +50,7 @@ mod tests {
     fn to_json() {
         let node = InstructionRemainingAccountsNode {
             is_optional: false,
-            is_signer: IsAccountSigner::Either,
+            is_signer: IsSigner::Either,
             is_writable: true,
             docs: vec![].into(),
             value: ArgumentValueNode::new("myArgument").into(),
@@ -70,7 +70,7 @@ mod tests {
             node,
             InstructionRemainingAccountsNode {
                 is_optional: false,
-                is_signer: IsAccountSigner::Either,
+                is_signer: IsSigner::Either,
                 is_writable: true,
                 docs: vec![].into(),
                 value: ArgumentValueNode::new("myArgument").into(),