Generate Rust topLevel nodes (account, constant, error, event, instruction*, pda, program, root, …)

codama-attributes/src/codama_directives/account_directive.rs

@@ -68,13 +68,14 @@ impl AccountDirective {
             name: self.name.clone(),
             is_writable: self.is_writable,
             is_signer: self.is_signer,
-            is_optional: self.is_optional,
+            is_optional: if self.is_optional { Some(true) } else { None },
             docs: self.docs.clone(),
-            default_value: self
-                .default_value
-                .as_ref()
-                .map(|r| r.try_resolved().cloned())
-                .transpose()?,
+            default_value: Box::new(
+                self.default_value
+                    .as_ref()
+                    .map(|r| r.try_resolved().cloned())
+                    .transpose()?,
+            ),
         })
     }
 }

codama-attributes/src/codama_directives/argument_directive.rs

@@ -47,13 +47,14 @@ impl ArgumentDirective {
     pub fn to_instruction_argument_node(&self) -> CodamaResult<InstructionArgumentNode> {
         Ok(InstructionArgumentNode {
             name: self.name.clone(),
-            r#type: self.r#type.try_resolved()?.clone(),
+            r#type: Box::new(self.r#type.try_resolved()?.clone()),
             docs: self.docs.clone(),
-            default_value: self
-                .default_value
-                .as_ref()
-                .map(|r| r.try_resolved().cloned())
-                .transpose()?,
+            default_value: Box::new(
+                self.default_value
+                    .as_ref()
+                    .map(|r| r.try_resolved().cloned())
+                    .transpose()?,
+            ),
             default_value_strategy: self.default_value_strategy,
         })
     }

codama-attributes/src/codama_directives/enum_discriminator_directive.rs

@@ -4,8 +4,8 @@ use crate::{
 };
 use codama_errors::CodamaError;
 use codama_nodes::{
-    CamelCaseString, DefinedTypeNode, InstructionArgumentNode, NestedTypeNode, Node,
-    NumberFormat::U8, NumberTypeNode, StructFieldTypeNode, TypeNode,
+    CamelCaseString, InstructionArgumentNode, NestedTypeNode, Node, NumberFormat::U8,
+    NumberTypeNode, StructFieldTypeNode, TypeNode,
 };
 use codama_syn_helpers::{extensions::*, Meta};
 
@@ -73,14 +73,15 @@ impl<'a> TryFrom<&'a Attribute<'a>> for &'a EnumDiscriminatorDirective {
 
 impl From<&Option<Node>> for EnumDiscriminatorDirective {
     fn from(node: &Option<Node>) -> Self {
-        EnumDiscriminatorDirective {
-            size: match &node {
-                Some(Node::DefinedType(DefinedTypeNode {
-                    r#type: TypeNode::Enum(data),
-                    ..
-                })) => Some(data.size.clone()),
+        let size = match node {
+            Some(Node::DefinedType(defined_type)) => match defined_type.r#type.as_ref() {
+                TypeNode::Enum(data) => Some(data.size.clone()),
                 _ => None,
             },
+            _ => None,
+        };
+        EnumDiscriminatorDirective {
+            size,
             ..EnumDiscriminatorDirective::default()
         }
     }

codama-attributes/src/codama_directives/error_directive.rs

@@ -4,7 +4,7 @@ use codama_syn_helpers::{extensions::*, Meta};
 
 #[derive(Debug, PartialEq, Default, Clone)]
 pub struct ErrorDirective {
-    pub code: Option<usize>,
+    pub code: Option<u32>,
     pub message: Option<String>,
 }
 
@@ -17,7 +17,7 @@ impl ErrorDirective {
 impl ErrorDirective {
     pub fn parse(meta: &Meta) -> syn::Result<Self> {
         let pl = meta.assert_directive("error")?.as_path_list()?;
-        let mut code = SetOnce::<usize>::new("code");
+        let mut code = SetOnce::<u32>::new("code");
         let mut message = SetOnce::<String>::new("message");
         pl.each(|ref meta| match meta.path_str().as_str() {
             "code" => code.set(meta.as_value()?.as_expr()?.as_unsigned_integer()?, meta),

codama-korok-visitors/src/set_accounts_visitor.rs

@@ -181,7 +181,7 @@ fn parse_struct(
     // Ensure we have a `DefinedTypeNode` to work with.
     if let Some(Node::DefinedType(node)) = &korok.node {
         // Ensure the data type is a struct.
-        if let Ok(data) = NestedTypeNode::<StructTypeNode>::try_from(node.r#type.clone()) {
+        if let Ok(data) = NestedTypeNode::<StructTypeNode>::try_from((*node.r#type).clone()) {
             return Ok((node.name.clone(), data));
         };
     };

codama-korok-visitors/src/set_default_values_visitor.rs

@@ -111,7 +111,7 @@ fn get_node_with_default_value(
         // Handle instruction arguments.
         Some(Node::InstructionArgument(argument)) => Ok(Some(
             InstructionArgumentNode {
-                default_value: Some(resolved_node.clone()),
+                default_value: Box::new(Some(resolved_node.clone())),
                 default_value_strategy: directive.default_value_strategy,
                 ..argument.clone()
             }

codama-korok-visitors/src/set_errors_visitor.rs

@@ -8,7 +8,7 @@ use codama_syn_helpers::extensions::*;
 
 pub struct SetErrorsVisitor {
     combine_types: CombineTypesVisitor,
-    enum_current_discriminator: usize,
+    enum_current_discriminator: u32,
 }
 
 impl Default for SetErrorsVisitor {

codama-korok-visitors/src/set_events_visitor.rs

@@ -168,7 +168,7 @@ fn parse_struct(
     // Ensure we have a `DefinedTypeNode` to work with.
     if let Some(Node::DefinedType(node)) = &korok.node {
         // Ensure the data type is a struct.
-        if let Ok(data) = NestedTypeNode::<StructTypeNode>::try_from(node.r#type.clone()) {
+        if let Ok(data) = NestedTypeNode::<StructTypeNode>::try_from((*node.r#type).clone()) {
             return Ok((node.name.clone(), data));
         };
     };

codama-korok-visitors/src/set_instructions_visitors.rs

@@ -146,7 +146,9 @@ impl KorokVisitor for SetInstructionsVisitor {
         let (name, data) = parse_enum_variant(korok, &self.enum_name)?;
         let discriminator = InstructionArgumentNode {
             default_value_strategy: Some(DefaultValueStrategy::Omitted),
-            default_value: Some(NumberValueNode::new(current_discriminator as u64).into()),
+            default_value: Box::new(Some(
+                NumberValueNode::new(current_discriminator as u64).into(),
+            )),
             ..InstructionArgumentNode::from(&self.enum_discriminator)
         };
         let mut discriminators = DiscriminatorDirective::nodes(&korok.attributes);
@@ -176,11 +178,10 @@ impl KorokVisitor for SetInstructionsVisitor {
     }
 }
 
-fn parse_optional_account_strategy(attributes: &Attributes) -> OptionalAccountStrategy {
+fn parse_optional_account_strategy(attributes: &Attributes) -> Option<OptionalAccountStrategy> {
     attributes
         .get_last(OptionalAccountStrategyDirective::filter)
         .map(|directive| directive.strategy)
-        .unwrap_or_default()
 }
 
 fn parse_accounts(
@@ -243,7 +244,7 @@ fn parse_arguments(
             };
 
             Ok(InstructionArgumentNode {
-                default_value: Some(directive.node.try_resolved()?.clone()),
+                default_value: Box::new(Some(directive.node.try_resolved()?.clone())),
                 default_value_strategy: directive.default_value_strategy,
                 ..argument
             })
@@ -282,7 +283,7 @@ fn parse_struct(
     // Ensure we have a `DefinedTypeNode` to work with.
     if let Some(Node::DefinedType(node)) = &korok.node {
         // Ensure the data type is a struct.
-        if let TypeNode::Struct(data) = node.r#type.clone() {
+        if let TypeNode::Struct(data) = (*node.r#type).clone() {
             return Ok((node.name.clone(), data));
         };
     };

codama-korok-visitors/tests/combine_modules_visitor/program_node.rs

@@ -1,7 +1,8 @@
 use super::utils::{combine_modules, CombineModulesInput};
 use codama_nodes::{
     AccountNode, ConstantNode, DefinedTypeNode, Docs, ErrorNode, EventNode, InstructionNode, Node,
-    NumberTypeNode, NumberValueNode, PdaNode, ProgramNode, RootNode, StructTypeNode, U8,
+    NumberTypeNode, NumberValueNode, PdaNode, ProgramNode, ProgramOrigin, RootNode, StructTypeNode,
+    U8,
 };
 
 #[test]
@@ -84,11 +85,16 @@ fn it_does_not_override_the_program_data_when_set() {
 /// Returns a ProgramNode with the given public key
 /// whilst using an identifier to tag all fields with unique values.
 fn get_mock_program(identifier: &str, public_key: &str) -> ProgramNode {
+    let origin = if identifier == "a" {
+        ProgramOrigin::Anchor
+    } else {
+        ProgramOrigin::Shank
+    };
     ProgramNode {
         name: format!("program_{}", identifier).into(),
         public_key: public_key.into(),
         version: format!("version_{}", identifier),
-        origin: Some(format!("origin_{}", identifier)),
+        origin: Some(origin),
         docs: Docs::new().add_doc(format!("docs_{}", identifier)),
         accounts: vec![AccountNode::new(
             format!("account_{}", identifier),

codama-korok-visitors/tests/set_default_values_visitor.rs

@@ -96,7 +96,7 @@ fn it_sets_default_values_to_instruction_argument_nodes() -> CodamaResult<()> {
         korok.node,
         Some(
             InstructionArgumentNode {
-                default_value: Some(PayerValueNode::new().into()),
+                default_value: Box::new(Some(PayerValueNode::new().into())),
                 ..InstructionArgumentNode::new("authority", PublicKeyTypeNode::new())
             }
             .into()
@@ -119,7 +119,7 @@ fn it_sets_omitted_default_values_to_instruction_argument_nodes() -> CodamaResul
         korok.node,
         Some(
             InstructionArgumentNode {
-                default_value: Some(PayerValueNode::new().into()),
+                default_value: Box::new(Some(PayerValueNode::new().into())),
                 default_value_strategy: Some(codama_nodes::DefaultValueStrategy::Omitted),
                 ..InstructionArgumentNode::new("authority", PublicKeyTypeNode::new())
             }