Generate contextualValue nodes; align Rust variant names with the derived rule

codama-nodes/src/contextual_value_nodes/account_bump_value_node.rs

@@ -1,17 +1,4 @@
-use crate::{CamelCaseString, HasName};
-use codama_nodes_derive::node;
-
-#[node]
-pub struct AccountBumpValueNode {
-    // Data.
-    pub name: CamelCaseString,
-}
-
-impl From<AccountBumpValueNode> for crate::Node {
-    fn from(val: AccountBumpValueNode) -> Self {
-        crate::Node::ContextualValue(val.into())
-    }
-}
+use crate::{AccountBumpValueNode, CamelCaseString};
 
 impl AccountBumpValueNode {
     pub fn new<T>(name: T) -> Self
@@ -22,12 +9,6 @@ impl AccountBumpValueNode {
     }
 }
 
-impl HasName for AccountBumpValueNode {
-    fn name(&self) -> &CamelCaseString {
-        &self.name
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

codama-nodes/src/contextual_value_nodes/account_value_node.rs

@@ -1,17 +1,4 @@
-use crate::{CamelCaseString, HasName};
-use codama_nodes_derive::node;
-
-#[node]
-pub struct AccountValueNode {
-    // Data.
-    pub name: CamelCaseString,
-}
-
-impl From<AccountValueNode> for crate::Node {
-    fn from(val: AccountValueNode) -> Self {
-        crate::Node::ContextualValue(val.into())
-    }
-}
+use crate::{AccountValueNode, CamelCaseString};
 
 impl AccountValueNode {
     pub fn new<T>(name: T) -> Self
@@ -22,12 +9,6 @@ impl AccountValueNode {
     }
 }
 
-impl HasName for AccountValueNode {
-    fn name(&self) -> &CamelCaseString {
-        &self.name
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

codama-nodes/src/contextual_value_nodes/argument_value_node.rs

@@ -1,17 +1,4 @@
-use crate::{CamelCaseString, HasName};
-use codama_nodes_derive::node;
-
-#[node]
-pub struct ArgumentValueNode {
-    // Data.
-    pub name: CamelCaseString,
-}
-
-impl From<ArgumentValueNode> for crate::Node {
-    fn from(val: ArgumentValueNode) -> Self {
-        crate::Node::ContextualValue(val.into())
-    }
-}
+use crate::{ArgumentValueNode, CamelCaseString};
 
 impl ArgumentValueNode {
     pub fn new<T>(name: T) -> Self
@@ -22,12 +9,6 @@ impl ArgumentValueNode {
     }
 }
 
-impl HasName for ArgumentValueNode {
-    fn name(&self) -> &CamelCaseString {
-        &self.name
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

codama-nodes/src/contextual_value_nodes/conditional_value_node.rs

@@ -1,69 +1,40 @@
-use crate::{
-    AccountValueNode, ArgumentValueNode, InstructionInputValueNode, ResolverValueNode, ValueNode,
-};
-use codama_nodes_derive::{node, node_union};
-
-#[node]
-pub struct ConditionalValueNode {
-    // Children.
-    pub condition: ConditionalValueCondition,
-    #[serde(skip_serializing_if = "crate::is_default")]
-    pub value: Option<ValueNode>,
-    #[serde(skip_serializing_if = "crate::is_default")]
-    pub if_true: Box<Option<InstructionInputValueNode>>,
-    #[serde(skip_serializing_if = "crate::is_default")]
-    pub if_false: Box<Option<InstructionInputValueNode>>,
-}
-
-impl From<ConditionalValueNode> for crate::Node {
-    fn from(val: ConditionalValueNode) -> Self {
-        crate::Node::ContextualValue(val.into())
-    }
-}
-
-#[node_union]
-pub enum ConditionalValueCondition {
-    Account(AccountValueNode),
-    Argument(ArgumentValueNode),
-    Resolver(ResolverValueNode),
-}
-
 #[cfg(test)]
 mod tests {
-    use crate::NumberValueNode;
-
-    use super::*;
+    use crate::{
+        AccountValueNode, ArgumentValueNode, ConditionalValueCondition, ConditionalValueNode,
+        InstructionInputValueNode, NumberValueNode, ValueNode,
+    };
 
     #[test]
     fn direct_instantiation() {
         let node = ConditionalValueNode {
-            condition: ArgumentValueNode::new("myArgument").into(),
-            value: Some(NumberValueNode::new(42).into()),
+            condition: Box::new(ArgumentValueNode::new("myArgument").into()),
+            value: Box::new(Some(NumberValueNode::new(42).into())),
             if_true: Box::new(Some(AccountValueNode::new("myOtherAccount").into())),
             if_false: Box::new(None),
         };
         assert_eq!(
-            node.condition,
+            *node.condition,
             ConditionalValueCondition::Argument(ArgumentValueNode::new("myArgument"))
         );
         assert_eq!(
-            node.value,
+            *node.value,
             Some(ValueNode::Number(NumberValueNode::new(42)))
         );
         assert_eq!(
             *node.if_true,
-            Some(InstructionInputValueNode::Account(AccountValueNode::new(
-                "myOtherAccount"
-            )))
+            Some(InstructionInputValueNode::AccountValue(
+                AccountValueNode::new("myOtherAccount")
+            ))
         );
         assert_eq!(*node.if_false, None);
     }
 
     #[test]
     fn to_json() {
         let node = ConditionalValueNode {
-            condition: ArgumentValueNode::new("myArgument").into(),
-            value: Some(NumberValueNode::new(42).into()),
+            condition: Box::new(ArgumentValueNode::new("myArgument").into()),
+            value: Box::new(Some(NumberValueNode::new(42).into())),
             if_true: Box::new(Some(AccountValueNode::new("myOtherAccount").into())),
             if_false: Box::new(None),
         };
@@ -81,8 +52,8 @@ mod tests {
         assert_eq!(
             node,
             ConditionalValueNode {
-                condition: ArgumentValueNode::new("myArgument").into(),
-                value: Some(NumberValueNode::new(42u32).into()),
+                condition: Box::new(ArgumentValueNode::new("myArgument").into()),
+                value: Box::new(Some(NumberValueNode::new(42u32).into())),
                 if_true: Box::new(Some(AccountValueNode::new("myOtherAccount").into())),
                 if_false: Box::new(None),
             }

codama-nodes/src/contextual_value_nodes/contextual_value_node.rs

@@ -1,30 +1,6 @@
-use crate::{
-    AccountBumpValueNode, AccountValueNode, ArgumentValueNode, ConditionalValueNode, HasKind,
-    IdentityValueNode, PayerValueNode, PdaSeedValueNode, PdaValueNode, ProgramIdValueNode,
-    ResolverValueNode,
-};
-use codama_nodes_derive::{node_union, RegisteredNodes};
-
-#[derive(RegisteredNodes)]
-#[node_union]
-pub enum RegisteredContextualValueNode {
-    Account(AccountValueNode),
-    AccountBump(AccountBumpValueNode),
-    Argument(ArgumentValueNode),
-    Conditional(ConditionalValueNode),
-    Identity(IdentityValueNode),
-    Payer(PayerValueNode),
-    Pda(PdaValueNode),
-    ProgramId(ProgramIdValueNode),
-    Resolver(ResolverValueNode),
-
-    #[registered]
-    PdaSeed(PdaSeedValueNode),
-}
-
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use crate::{ContextualValueNode, HasKind, ProgramIdValueNode, RegisteredContextualValueNode};
 
     #[test]
     fn kind_from_standalone() {

codama-nodes/src/contextual_value_nodes/identity_value_node.rs

@@ -1,14 +1,4 @@
-use codama_nodes_derive::node;
-
-#[node]
-#[derive(Copy, Default)]
-pub struct IdentityValueNode {}
-
-impl From<IdentityValueNode> for crate::Node {
-    fn from(val: IdentityValueNode) -> Self {
-        crate::Node::ContextualValue(val.into())
-    }
-}
+use crate::IdentityValueNode;
 
 impl IdentityValueNode {
     pub fn new() -> Self {

codama-nodes/src/contextual_value_nodes/mod.rs

@@ -9,15 +9,3 @@ mod pda_seed_value_node;
 mod pda_value_node;
 mod program_id_value_node;
 mod resolver_value_node;
-
-pub use account_bump_value_node::*;
-pub use account_value_node::*;
-pub use argument_value_node::*;
-pub use conditional_value_node::*;
-pub use contextual_value_node::*;
-pub use identity_value_node::*;
-pub use payer_value_node::*;
-pub use pda_seed_value_node::*;
-pub use pda_value_node::*;
-pub use program_id_value_node::*;
-pub use resolver_value_node::*;

codama-nodes/src/contextual_value_nodes/payer_value_node.rs

@@ -1,14 +1,4 @@
-use codama_nodes_derive::node;
-
-#[node]
-#[derive(Copy, Default)]
-pub struct PayerValueNode {}
-
-impl From<PayerValueNode> for crate::Node {
-    fn from(val: PayerValueNode) -> Self {
-        crate::Node::ContextualValue(val.into())
-    }
-}
+use crate::PayerValueNode;
 
 impl PayerValueNode {
     pub fn new() -> Self {

codama-nodes/src/contextual_value_nodes/pda_seed_value_node.rs

@@ -1,25 +1,4 @@
-use crate::{
-    AccountValueNode, ArgumentValueNode, ArrayValueNode, BooleanValueNode, BytesValueNode,
-    CamelCaseString, ConstantValueNode, EnumValueNode, HasName, MapValueNode, NoneValueNode,
-    NumberValueNode, PublicKeyValueNode, SetValueNode, SomeValueNode, StringValueNode,
-    StructValueNode, TupleValueNode, ValueNode,
-};
-use codama_nodes_derive::{node, node_union};
-
-#[node]
-pub struct PdaSeedValueNode {
-    // Data.
-    pub name: CamelCaseString,
-
-    // Children.
-    pub value: PdaSeedValueValue,
-}
-
-impl From<PdaSeedValueNode> for crate::Node {
-    fn from(val: PdaSeedValueNode) -> Self {
-        crate::Node::ContextualValue(val.into())
-    }
-}
+use crate::{CamelCaseString, PdaSeedValueNode, PdaSeedValueValue, ValueNode};
 
 impl PdaSeedValueNode {
     pub fn new<T, U>(name: T, value: U) -> Self
@@ -29,39 +8,15 @@ impl PdaSeedValueNode {
     {
         Self {
             name: name.into(),
-            value: value.into(),
+            value: Box::new(value.into()),
         }
     }
 }
 
-impl HasName for PdaSeedValueNode {
-    fn name(&self) -> &CamelCaseString {
-        &self.name
-    }
-}
-
-#[node_union]
-pub enum PdaSeedValueValue {
-    Account(AccountValueNode),
-    Argument(ArgumentValueNode),
-
-    // ValueNodes.
-    Array(ArrayValueNode),
-    Boolean(BooleanValueNode),
-    Bytes(BytesValueNode),
-    Constant(ConstantValueNode),
-    Enum(EnumValueNode),
-    Map(MapValueNode),
-    None(NoneValueNode),
-    Number(NumberValueNode),
-    PublicKey(PublicKeyValueNode),
-    Set(SetValueNode),
-    Some(SomeValueNode),
-    String(StringValueNode),
-    Struct(StructValueNode),
-    Tuple(TupleValueNode),
-}
-
+/// Bridge from the broader `ValueNode` union into `PdaSeedValueValue`.
+/// `PdaSeedValueValue` is `accountValueNode | argumentValueNode | valueNode`
+/// (16 variants total) — every value-node leaf maps to its same-named
+/// `PdaSeedValueValue` variant.
 impl From<ValueNode> for PdaSeedValueValue {
     fn from(value: ValueNode) -> Self {
         match value {
@@ -85,16 +40,15 @@ impl From<ValueNode> for PdaSeedValueValue {
 
 #[cfg(test)]
 mod tests {
-    use crate::NumberValueNode;
-
     use super::*;
+    use crate::NumberValueNode;
 
     #[test]
     fn new() {
         let node = PdaSeedValueNode::new("answer", NumberValueNode::new(42));
         assert_eq!(node.name, CamelCaseString::from("answer"));
         assert_eq!(
-            node.value,
+            *node.value,
             PdaSeedValueValue::Number(NumberValueNode::new(42))
         );
     }