idl: Support NonZero<num> in IDL

Author: jamie-osec

cli/src/lib.rs

@@ -2899,6 +2899,9 @@ fn deserialize_idl_type_to_json(
                 deserialize_idl_type_to_json(ty, data, parent_idl)?
             }
         }
+        IdlType::NonZero(ty) => {
+            deserialize_idl_type_to_json(ty, data, parent_idl)?
+        }
         IdlType::Vec(ty) => {
             let size: usize = <u32 as AnchorDeserialize>::deserialize(data)?
                 .try_into()

idl/spec/src/lib.rs

@@ -306,6 +306,7 @@ pub enum IdlType {
         #[serde(default, skip_serializing_if = "is_default")]
         generics: Vec<IdlGenericArg>,
     },
+    NonZero(Box<IdlType>),
     Generic(String),
 }
 
@@ -355,6 +356,15 @@ impl FromStr for IdlType {
                     return Ok(IdlType::Vec(Box::new(inner_ty)));
                 }
 
+                if let Some(inner) = s.strip_prefix("NonZero<") {
+                    let inner_ty = Self::from_str(
+                        inner
+                            .strip_suffix('>')
+                            .ok_or_else(|| anyhow!("Invalid NonZero"))?,
+                    )?;
+                    return Ok(IdlType::NonZero(Box::new(inner_ty)));
+                }
+
                 if s.starts_with('[') {
                     fn array_from_str(inner: &str) -> IdlType {
                         match inner.strip_suffix(']') {
@@ -499,4 +509,12 @@ mod tests {
             }
         )
     }
+
+    #[test]
+    fn nonzero() {
+        assert_eq!(
+            IdlType::from_str("NonZero<u64>").unwrap(),
+            IdlType::NonZero(Box::new(IdlType::U64)),
+        )
+    }
 }

idl/src/convert.rs

@@ -244,6 +244,7 @@ mod legacy {
         Array(Box<IdlType>, usize),
         GenericLenArray(Box<IdlType>, String),
         Generic(String),
+        NonZero(Box<IdlType>),
         DefinedWithTypeArgs {
             name: String,
             args: Vec<IdlDefinedTypeArg>,
@@ -491,6 +492,7 @@ mod legacy {
                 IdlType::GenericLenArray(ty, generic) => {
                     t::IdlType::Array(ty.into(), t::IdlArrayLen::Generic(generic))
                 }
+                IdlType::NonZero(ty) => t::IdlType::NonZero(ty.into()),
                 _ => serde_json::to_value(value)
                     .and_then(serde_json::from_value)
                     .unwrap(),

lang/attribute/program/src/declare_program/common.rs

@@ -89,6 +89,7 @@ pub fn convert_idl_type_to_str(ty: &IdlType) -> String {
             .map(|generics| format!("{name}<{generics}>"))
             .unwrap_or(name.into()),
         IdlType::Generic(ty) => ty.into(),
+        IdlType::NonZero(ty) => format!("NonZero<{}>", convert_idl_type_to_str(ty)),
         _ => unimplemented!("{ty:?}"),
     }
 }
@@ -309,6 +310,7 @@ fn can_derive_copy_ty(ty: &IdlType, ty_defs: &[IdlTypeDef]) -> bool {
             .map(|ty_def| can_derive_copy(ty_def, ty_defs))
             .expect("Type def must exist"),
         IdlType::Bytes | IdlType::String | IdlType::Vec(_) | IdlType::Generic(_) => false,
+        IdlType::NonZero(inner) => can_derive_copy_ty(inner, ty_defs),
         _ => true,
     }
 }
@@ -333,6 +335,7 @@ fn can_derive_default_ty(ty: &IdlType, ty_defs: &[IdlTypeDef]) -> bool {
             .map(|ty_def| can_derive_default(ty_def, ty_defs))
             .expect("Type def must exist"),
         IdlType::Generic(_) => false,
+        IdlType::NonZero(_) => false,
         _ => true,
     }
 }

lang/syn/src/idl/defined.rs

@@ -416,6 +416,15 @@ pub fn gen_idl_type(
         syn::Type::Path(path) if the_only_segment_is(path, "i128") => {
             Ok((quote! { #idl::IdlType::I128 }, vec![]))
         }
+        syn::Type::Path(path) if the_only_segment_is(path, "NonZero") => {
+            let segment = get_first_segment(path);
+            let arg = get_angle_bracketed_type_args(segment)
+                .into_iter()
+                .next()
+                .unwrap();
+            let (inner, defined) = gen_idl_type(arg, generic_params)?;
+            Ok((quote! { #idl::IdlType::NonZero(Box::new(#inner)) }, defined))
+        }
         syn::Type::Path(path)
             if the_only_segment_is(path, "String") || the_only_segment_is(path, "str") =>
         {