Merge pull request #1011 from schungx/master

Handle Option fields in CustomType derive

Author: schungx

CHANGELOG.md

@@ -15,8 +15,9 @@ Enhancements
 -----------
 
 * `CustomType` derive macro now supports generic types (thanks [`@ProphetOSpam`](https://github.com/ProphetOSpam) [#999](https://github.com/rhaiscript/rhai/pull/999)). The `rhai_codegen` crate dependency is bumped to `3.0.0` or later.
+* `CustomType` derive macro now handles `Option` fields (thanks [`@agersant`](https://github.com/agersant) [#1005](https://github.com/rhaiscript/rhai/pull/1005)).
 * `Engine::eval_binary_op` is added to quickly compare two `Dynamic` values.
-* Better handling for 32-bit architectures.
+* Better handling for 32-bit architectures and enhanced safety by replacing casts with `try_from` (thanks [`@therealprof`](https://github.com/therealprof) [#1009](https://github.com/rhaiscript/rhai/pull/1009)).
 
 
 Version 1.22.2

Cargo.toml

@@ -25,7 +25,7 @@ num-traits = { version = "0.2.14", default-features = false }
 once_cell = { version = "1.20.1", default-features = false, features = ["race", "portable-atomic", "alloc"] }
 bitflags = { version = "2.3.3", default-features = false }
 smartstring = { version = "1.0.0", default-features = false }
-rhai_codegen = { version = "3.0.0", path = "codegen" }
+rhai_codegen = { version = "3.1.0", path = "codegen" }
 
 no-std-compat = { git = "https://gitlab.com/jD91mZM2/no-std-compat.git", version = "0.4.1", default-features = false, features = ["alloc"], optional = true }
 libm = { version = "0.2.0", default-features = false, optional = true }

codegen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rhai_codegen"
-version = "3.0.0"
+version = "3.1.0"
 edition = "2018"
 resolver = "2"
 authors = ["jhwgh1968", "Stephen Chung"]

codegen/src/custom_type.rs

@@ -183,6 +183,51 @@ pub fn derive_custom_type_impl(input: DeriveInput) -> TokenStream {
     }
 }
 
+// Code lifted from: https://stackoverflow.com/questions/55271857/how-can-i-get-the-t-from-an-optiont-when-using-syn
+fn extract_type_from_option(ty: &syn::Type) -> Option<&syn::Type> {
+    use syn::{GenericArgument, Path, PathArguments, PathSegment};
+
+    fn extract_type_path(ty: &syn::Type) -> Option<&Path> {
+        match *ty {
+            syn::Type::Path(ref type_path) if type_path.qself.is_none() => Some(&type_path.path),
+            _ => None,
+        }
+    }
+
+    // TODO store (with lazy static) the vec of string
+    // TODO maybe optimization, reverse the order of segments
+    fn extract_option_segment(path: &Path) -> Option<&PathSegment> {
+        let idents_of_path = path
+            .segments
+            .iter()
+            .into_iter()
+            .fold(String::new(), |mut acc, v| {
+                acc.push_str(&v.ident.to_string());
+                acc.push('|');
+                acc
+            });
+        vec!["Option|", "std|option|Option|", "core|option|Option|"]
+            .into_iter()
+            .find(|s| &idents_of_path == *s)
+            .and_then(|_| path.segments.last())
+    }
+
+    extract_type_path(ty)
+        .and_then(|path| extract_option_segment(path))
+        .and_then(|path_seg| {
+            let type_params = &path_seg.arguments;
+            // It should have only on angle-bracketed param ("<String>"):
+            match *type_params {
+                PathArguments::AngleBracketed(ref params) => params.args.first(),
+                _ => None,
+            }
+        })
+        .and_then(|generic_arg| match *generic_arg {
+            GenericArgument::Type(ref ty) => Some(ty),
+            _ => None,
+        })
+}
+
 fn scan_fields(fields: &[&Field], accessors: &mut Vec<TokenStream>, errors: &mut Vec<TokenStream>) {
     for (i, &field) in fields.iter().enumerate() {
         let mut map_name = None;
@@ -314,21 +359,54 @@ fn scan_fields(fields: &[&Field], accessors: &mut Vec<TokenStream>, errors: &mut
             quote! { #index }
         };
 
+        // Handle `Option` fields
+        let option_type = extract_type_from_option(&field.ty);
+
         // Override functions
-        let get = match (get_mut_fn, get_fn) {
+
+        let get_impl = match (get_mut_fn, get_fn) {
             (Some(func), _) => func,
             (None, Some(func)) => quote! { |obj: &mut Self| #func(&*obj) },
-            (None, None) => quote! { |obj: &mut Self| obj.#field_name.clone() },
+            (None, None) => {
+                if let Some(_) = option_type {
+                    quote! { |obj: &mut Self| obj.#field_name.clone().map_or(Dynamic::UNIT, Dynamic::from) }
+                } else {
+                    quote! { |obj: &mut Self| obj.#field_name.clone() }
+                }
+            }
         };
 
-        let set = set_fn.unwrap_or_else(|| quote! { |obj: &mut Self, val| obj.#field_name = val });
+        let set_impl = set_fn.unwrap_or_else(|| {
+            if let Some(typ) = option_type {
+                quote! {
+                    |obj: &mut Self, val: Dynamic| {
+                        if val.is_unit() {
+                            obj.#field_name = None;
+                            Ok(())
+                        } else if let Some(x) = val.read_lock::<#typ>() {
+                            obj.#field_name = Some(x.clone());
+                            Ok(())
+                        } else {
+                            Err(Box::new(EvalAltResult::ErrorMismatchDataType(
+                                stringify!(#typ).to_string(),
+                                val.type_name().to_string(),
+                                Position::NONE
+                            )))
+                        }
+                    }
+                }
+            } else {
+                quote! { |obj: &mut Self, val| obj.#field_name = val }
+            }
+        });
+
         let name = map_name.unwrap_or_else(|| quote! { stringify!(#field_name) });
 
         accessors.push({
             let method = if readonly {
-                quote! { builder.with_get(#name, #get) }
+                quote! { builder.with_get(#name, #get_impl) }
             } else {
-                quote! { builder.with_get_set(#name, #get, #set) }
+                quote! { builder.with_get_set(#name, #get_impl, #set_impl) }
             };
 
             #[cfg(feature = "metadata")]

codegen/tests/test_custom_type.rs

@@ -1,4 +1,4 @@
-use rhai::{CustomType, Engine, TypeBuilder, INT};
+use rhai::{CustomType, Dynamic, Engine, EvalAltResult, Position, TypeBuilder, INT};
 
 // Sanity check to make sure everything compiles
 
@@ -21,6 +21,7 @@ pub struct Foo {
     pub(crate) baz: String,
     #[rhai_type(set = Self::set_qux)]
     pub qux: Vec<INT>,
+    pub maybe: Option<INT>,
 }
 
 impl Foo {

tests/build_type.rs

@@ -1,5 +1,5 @@
 #![cfg(not(feature = "no_object"))]
-use rhai::{CustomType, Engine, EvalAltResult, Position, TypeBuilder, INT};
+use rhai::{CustomType, Dynamic, Engine, EvalAltResult, Position, TypeBuilder, INT};
 use std::cmp::Ordering;
 
 #[test]
@@ -170,6 +170,7 @@ fn test_build_type_macro() {
         baz: bool,
         #[rhai_type(set = Self::set_hello)]
         hello: String,
+        maybe: Option<bool>,
     }
 
     impl Foo {
@@ -191,6 +192,7 @@ fn test_build_type_macro() {
                 bar: 5,
                 baz: false,
                 hello: "hey".to_string(),
+                maybe: None,
             });
         }
     }
@@ -207,6 +209,7 @@ fn test_build_type_macro() {
                     foo.hello = "world!";
                     foo.emphasize = true;
                     foo.hello = "yo";
+                    foo.maybe = true;
                     foo
                 "#
             )
@@ -215,7 +218,8 @@ fn test_build_type_macro() {
             dummy: 0,
             bar: 5,
             baz: true,
-            hello: "world!yo!!!!!".into()
+            hello: "world!yo!!!!!".into(),
+            maybe: Some(true),
         }
     );
 }