Generate count and discriminator nodes

codama-attributes/src/codama_directives/discriminator_directive.rs

@@ -35,8 +35,8 @@ impl DiscriminatorDirective {
         let mut encoding =
             SetOnce::<BytesEncoding>::new("encoding").initial_value(BytesEncoding::Base16);
         let mut field = SetOnce::<CamelCaseString>::new("field");
-        let mut offset = SetOnce::<usize>::new("offset").initial_value(0);
-        let mut size = SetOnce::<usize>::new("size");
+        let mut offset = SetOnce::<u64>::new("offset").initial_value(0);
+        let mut size = SetOnce::<u64>::new("size");
         pl.each(|ref meta| match meta.path_str().as_str() {
             "bytes" => {
                 if kind != DiscriminatorKind::Constant {

codama-korok-visitors/src/identify_field_types_visitor.rs

@@ -97,7 +97,7 @@ pub fn get_type_node(ty: &syn::Type) -> Option<TypeNode> {
             }
         }
         syn::Type::Array(syn::TypeArray { elem, len, .. }) => {
-            let Ok(size) = len.as_unsigned_integer::<usize>() else {
+            let Ok(size) = len.as_unsigned_integer::<u64>() else {
                 return None;
             };
             get_type_node(elem)

codama-nodes/src/count_nodes/count_node.rs

@@ -1,17 +1,6 @@
-use crate::{FixedCountNode, PrefixedCountNode, RemainderCountNode};
-use codama_nodes_derive::node_union;
-
-#[node_union]
-pub enum CountNode {
-    Fixed(FixedCountNode),
-    Prefixed(PrefixedCountNode),
-    Remainder(RemainderCountNode),
-}
-
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::HasKind;
+    use crate::{CountNode, HasKind, RemainderCountNode};
 
     #[test]
     fn kind() {

codama-nodes/src/count_nodes/fixed_count_node.rs

@@ -1,20 +1,7 @@
-use codama_nodes_derive::node;
-
-#[node]
-#[derive(Copy)]
-pub struct FixedCountNode {
-    // Data.
-    pub value: usize,
-}
-
-impl From<FixedCountNode> for crate::Node {
-    fn from(val: FixedCountNode) -> Self {
-        crate::Node::Count(val.into())
-    }
-}
+use crate::FixedCountNode;
 
 impl FixedCountNode {
-    pub fn new(value: usize) -> Self {
+    pub fn new(value: u64) -> Self {
         Self { value }
     }
 }

codama-nodes/src/count_nodes/mod.rs

@@ -2,8 +2,3 @@ mod count_node;
 mod fixed_count_node;
 mod prefixed_count_node;
 mod remainder_count_node;
-
-pub use count_node::*;
-pub use fixed_count_node::*;
-pub use prefixed_count_node::*;
-pub use remainder_count_node::*;

codama-nodes/src/count_nodes/prefixed_count_node.rs

@@ -1,17 +1,4 @@
-use crate::{NestedTypeNode, NumberTypeNode};
-use codama_nodes_derive::node;
-
-#[node]
-pub struct PrefixedCountNode {
-    // Data.
-    pub prefix: NestedTypeNode<NumberTypeNode>,
-}
-
-impl From<PrefixedCountNode> for crate::Node {
-    fn from(val: PrefixedCountNode) -> Self {
-        crate::Node::Count(val.into())
-    }
-}
+use crate::{NestedTypeNode, NumberTypeNode, PrefixedCountNode};
 
 impl PrefixedCountNode {
     pub fn new<T>(prefix: T) -> Self

codama-nodes/src/count_nodes/remainder_count_node.rs

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

codama-nodes/src/discriminator_nodes/constant_discriminator_node.rs

@@ -1,23 +1,7 @@
-use crate::ConstantValueNode;
-use codama_nodes_derive::node;
-
-#[node]
-pub struct ConstantDiscriminatorNode {
-    // Data.
-    pub offset: usize,
-
-    // Children.
-    pub constant: ConstantValueNode,
-}
-
-impl From<ConstantDiscriminatorNode> for crate::Node {
-    fn from(val: ConstantDiscriminatorNode) -> Self {
-        crate::Node::Discriminator(val.into())
-    }
-}
+use crate::{ConstantDiscriminatorNode, ConstantValueNode};
 
 impl ConstantDiscriminatorNode {
-    pub fn new<T>(constant: T, offset: usize) -> Self
+    pub fn new<T>(constant: T, offset: u64) -> Self
     where
         T: Into<ConstantValueNode>,
     {
@@ -30,9 +14,9 @@ impl ConstantDiscriminatorNode {
 
 #[cfg(test)]
 mod tests {
-    use crate::{Base16, NumberTypeNode, NumberValueNode, U32};
-
-    use super::*;
+    use crate::{
+        Base16, ConstantDiscriminatorNode, ConstantValueNode, NumberTypeNode, NumberValueNode, U32,
+    };
 
     #[test]
     fn new() {

codama-nodes/src/discriminator_nodes/discriminator_node.rs

@@ -1,17 +1,6 @@
-use crate::{ConstantDiscriminatorNode, FieldDiscriminatorNode, SizeDiscriminatorNode};
-use codama_nodes_derive::node_union;
-
-#[node_union]
-pub enum DiscriminatorNode {
-    Constant(ConstantDiscriminatorNode),
-    Field(FieldDiscriminatorNode),
-    Size(SizeDiscriminatorNode),
-}
-
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::HasKind;
+    use crate::{DiscriminatorNode, HasKind, SizeDiscriminatorNode};
 
     #[test]
     fn kind() {

codama-nodes/src/discriminator_nodes/field_discriminator_node.rs

@@ -1,21 +1,7 @@
-use crate::{CamelCaseString, HasName};
-use codama_nodes_derive::node;
-
-#[node]
-pub struct FieldDiscriminatorNode {
-    // Data.
-    pub name: CamelCaseString,
-    pub offset: usize,
-}
-
-impl From<FieldDiscriminatorNode> for crate::Node {
-    fn from(val: FieldDiscriminatorNode) -> Self {
-        crate::Node::Discriminator(val.into())
-    }
-}
+use crate::{CamelCaseString, FieldDiscriminatorNode};
 
 impl FieldDiscriminatorNode {
-    pub fn new<T>(name: T, offset: usize) -> Self
+    pub fn new<T>(name: T, offset: u64) -> Self
     where
         T: Into<CamelCaseString>,
     {
@@ -26,12 +12,6 @@ impl FieldDiscriminatorNode {
     }
 }
 
-impl HasName for FieldDiscriminatorNode {
-    fn name(&self) -> &CamelCaseString {
-        &self.name
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

codama-nodes/src/discriminator_nodes/mod.rs

@@ -2,8 +2,3 @@ mod constant_discriminator_node;
 mod discriminator_node;
 mod field_discriminator_node;
 mod size_discriminator_node;
-
-pub use constant_discriminator_node::*;
-pub use discriminator_node::*;
-pub use field_discriminator_node::*;
-pub use size_discriminator_node::*;

codama-nodes/src/discriminator_nodes/size_discriminator_node.rs

@@ -1,20 +1,7 @@
-use codama_nodes_derive::node;
-
-#[node]
-#[derive(Copy)]
-pub struct SizeDiscriminatorNode {
-    // Data.
-    pub size: usize,
-}
-
-impl From<SizeDiscriminatorNode> for crate::Node {
-    fn from(val: SizeDiscriminatorNode) -> Self {
-        crate::Node::Discriminator(val.into())
-    }
-}
+use crate::SizeDiscriminatorNode;
 
 impl SizeDiscriminatorNode {
-    pub fn new(size: usize) -> Self {
+    pub fn new(size: u64) -> Self {
         Self { size }
     }
 }

codama-nodes/src/generated/count_nodes/count_node.rs

@@ -0,0 +1,9 @@
+use crate::{FixedCountNode, PrefixedCountNode, RemainderCountNode};
+use codama_nodes_derive::node_union;
+
+#[node_union]
+pub enum CountNode {
+    Fixed(FixedCountNode),
+    Prefixed(PrefixedCountNode),
+    Remainder(RemainderCountNode),
+}

codama-nodes/src/generated/count_nodes/fixed_count_node.rs

@@ -0,0 +1,14 @@
+use codama_nodes_derive::node;
+
+#[node]
+#[derive(Copy)]
+pub struct FixedCountNode {
+    // Data.
+    pub value: u64,
+}
+
+impl From<FixedCountNode> for crate::Node {
+    fn from(val: FixedCountNode) -> Self {
+        crate::Node::Count(val.into())
+    }
+}

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

@@ -0,0 +1,9 @@
+mod count_node;
+mod fixed_count_node;
+mod prefixed_count_node;
+mod remainder_count_node;
+
+pub use count_node::*;
+pub use fixed_count_node::*;
+pub use prefixed_count_node::*;
+pub use remainder_count_node::*;

codama-nodes/src/generated/count_nodes/prefixed_count_node.rs

@@ -0,0 +1,14 @@
+use crate::{NestedTypeNode, NumberTypeNode};
+use codama_nodes_derive::node;
+
+#[node]
+pub struct PrefixedCountNode {
+    // Children.
+    pub prefix: NestedTypeNode<NumberTypeNode>,
+}
+
+impl From<PrefixedCountNode> for crate::Node {
+    fn from(val: PrefixedCountNode) -> Self {
+        crate::Node::Count(val.into())
+    }
+}

codama-nodes/src/generated/count_nodes/remainder_count_node.rs

@@ -0,0 +1,11 @@
+use codama_nodes_derive::node;
+
+#[node]
+#[derive(Copy, Default)]
+pub struct RemainderCountNode {}
+
+impl From<RemainderCountNode> for crate::Node {
+    fn from(val: RemainderCountNode) -> Self {
+        crate::Node::Count(val.into())
+    }
+}

codama-nodes/src/generated/discriminator_nodes/constant_discriminator_node.rs

@@ -0,0 +1,17 @@
+use crate::ConstantValueNode;
+use codama_nodes_derive::node;
+
+#[node]
+pub struct ConstantDiscriminatorNode {
+    // Data.
+    pub offset: u64,
+
+    // Children.
+    pub constant: ConstantValueNode,
+}
+
+impl From<ConstantDiscriminatorNode> for crate::Node {
+    fn from(val: ConstantDiscriminatorNode) -> Self {
+        crate::Node::Discriminator(val.into())
+    }
+}

codama-nodes/src/generated/discriminator_nodes/discriminator_node.rs

@@ -0,0 +1,9 @@
+use crate::{ConstantDiscriminatorNode, FieldDiscriminatorNode, SizeDiscriminatorNode};
+use codama_nodes_derive::node_union;
+
+#[node_union]
+pub enum DiscriminatorNode {
+    Constant(ConstantDiscriminatorNode),
+    Field(FieldDiscriminatorNode),
+    Size(SizeDiscriminatorNode),
+}

codama-nodes/src/generated/discriminator_nodes/field_discriminator_node.rs

@@ -0,0 +1,21 @@
+use crate::{CamelCaseString, HasName};
+use codama_nodes_derive::node;
+
+#[node]
+pub struct FieldDiscriminatorNode {
+    // Data.
+    pub name: CamelCaseString,
+    pub offset: u64,
+}
+
+impl From<FieldDiscriminatorNode> for crate::Node {
+    fn from(val: FieldDiscriminatorNode) -> Self {
+        crate::Node::Discriminator(val.into())
+    }
+}
+
+impl HasName for FieldDiscriminatorNode {
+    fn name(&self) -> &CamelCaseString {
+        &self.name
+    }
+}

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

@@ -0,0 +1,9 @@
+mod constant_discriminator_node;
+mod discriminator_node;
+mod field_discriminator_node;
+mod size_discriminator_node;
+
+pub use constant_discriminator_node::*;
+pub use discriminator_node::*;
+pub use field_discriminator_node::*;
+pub use size_discriminator_node::*;

codama-nodes/src/generated/discriminator_nodes/size_discriminator_node.rs

@@ -0,0 +1,14 @@
+use codama_nodes_derive::node;
+
+#[node]
+#[derive(Copy)]
+pub struct SizeDiscriminatorNode {
+    // Data.
+    pub size: u64,
+}
+
+impl From<SizeDiscriminatorNode> for crate::Node {
+    fn from(val: SizeDiscriminatorNode) -> Self {
+        crate::Node::Discriminator(val.into())
+    }
+}

codama-nodes/src/generated/mod.rs

@@ -1,3 +1,7 @@
+mod count_nodes;
+mod discriminator_nodes;
 mod link_nodes;
 
+pub use count_nodes::*;
+pub use discriminator_nodes::*;
 pub use link_nodes::*;

codama-nodes/src/lib.rs

@@ -29,9 +29,7 @@ mod value_nodes;
 pub use account_node::*;
 pub use constant_node::*;
 pub use contextual_value_nodes::*;
-pub use count_nodes::*;
 pub use defined_type_node::*;
-pub use discriminator_nodes::*;
 pub use error_node::*;
 pub use event_node::*;
 pub use generated::*;

codama-nodes/src/type_nodes/array_type_node.rs

@@ -29,7 +29,7 @@ impl ArrayTypeNode {
         }
     }
 
-    pub fn fixed<T>(item: T, value: usize) -> Self
+    pub fn fixed<T>(item: T, value: u64) -> Self
     where
         T: Into<TypeNode>,
     {