Merge pull request #952 from schungx/master

schungx · web-flow · commit 8ed4ea317ca1 · 2025-01-18T18:22:45.000+08:00
Bind native function to FnPtr
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -11,6 +11,11 @@ Bug fixes
 * `get_fn_metadata_list` function is marked `volatile`.
 * `no-std` plus `sync` should now build correctly (thanks [`stargazing-dino`](https://github.com/stargazing-dino) [947](https://github.com/rhaiscript/rhai/pull/947)).
 
+New Features
+------------
+
+* It is possible to create a function pointer (`FnPtr`) which binds to a native Rust function or closure via `FnPtr::from_dn` and `FnPtr::from_dyn_fn`. When called in script, the embedded function will be called.
+
 Enhancements
 ------------
 
diff --git a/src/api/register.rs b/src/api/register.rs
@@ -792,14 +792,14 @@ impl Engine {
     #[allow(dead_code)]
     pub(crate) fn collect_fn_metadata_impl<T>(
         &self,
-        ctx: Option<&NativeCallContext>,
+        _ctx: Option<&NativeCallContext>,
         mapper: impl Fn(crate::module::FuncInfo) -> Option<T> + Copy,
         include_standard_packages: bool,
     ) -> Vec<T> {
         let mut list = Vec::new();
 
         #[cfg(not(feature = "no_function"))]
-        if let Some(ctx) = ctx {
+        if let Some(ctx) = _ctx {
             ctx.iter_namespaces()
                 .flat_map(Module::iter_fn)
                 .filter_map(|(func, f)| {
@@ -829,7 +829,7 @@ impl Engine {
             .for_each(|v| list.push(v));
 
         #[cfg(not(feature = "no_module"))]
-        if let Some(ctx) = ctx {
+        if let Some(ctx) = _ctx {
             use crate::engine::NAMESPACE_SEPARATOR;
             use crate::SmartString;
 
diff --git a/src/eval/expr.rs b/src/eval/expr.rs
@@ -77,8 +77,8 @@ impl Engine {
                     let val: Dynamic = crate::FnPtr {
                         name: v.1.clone(),
                         curry: <_>::default(),
-                        environ: None,
-                        fn_def: Some(fn_def.clone()),
+                        env: None,
+                        typ: crate::types::fn_ptr::FnPtrType::Script(fn_def.clone()),
                     }
                     .into();
                     return Ok(val.into());
diff --git a/src/func/call.rs b/src/func/call.rs
diff --git a/src/func/function.rs b/src/func/function.rs
@@ -56,7 +56,7 @@ pub enum RhaiFunc {
         /// Shared reference to the [`ScriptFuncDef`][crate::ast::ScriptFuncDef] function definition.
         fn_def: Shared<crate::ast::ScriptFuncDef>,
         /// Encapsulated environment, if any.
-        environ: Option<Shared<EncapsulatedEnviron>>,
+        env: Option<Shared<EncapsulatedEnviron>>,
     },
 }
 
@@ -262,7 +262,7 @@ impl RhaiFunc {
             | Self::Plugin { .. } => None,
 
             #[cfg(not(feature = "no_function"))]
-            Self::Script { environ, .. } => environ.as_deref(),
+            Self::Script { env, .. } => env.as_deref(),
         }
     }
     /// Get a reference to an iterator function.
@@ -297,7 +297,7 @@ impl From<crate::ast::ScriptFuncDef> for RhaiFunc {
     fn from(fn_def: crate::ast::ScriptFuncDef) -> Self {
         Self::Script {
             fn_def: fn_def.into(),
-            environ: None,
+            env: None,
         }
     }
 }
@@ -306,10 +306,7 @@ impl From<crate::ast::ScriptFuncDef> for RhaiFunc {
 impl From<Shared<crate::ast::ScriptFuncDef>> for RhaiFunc {
     #[inline(always)]
     fn from(fn_def: Shared<crate::ast::ScriptFuncDef>) -> Self {
-        Self::Script {
-            fn_def,
-            environ: None,
-        }
+        Self::Script { fn_def, env: None }
     }
 }
 
diff --git a/src/func/script.rs b/src/func/script.rs
@@ -27,7 +27,7 @@ impl Engine {
         caches: &mut Caches,
         scope: &mut Scope,
         mut this_ptr: Option<&mut Dynamic>,
-        _environ: Option<&EncapsulatedEnviron>,
+        _env: Option<&EncapsulatedEnviron>,
         fn_def: &ScriptFuncDef,
         args: &mut FnCallArgs,
         rewind_scope: bool,
@@ -94,7 +94,7 @@ impl Engine {
         let orig_fn_resolution_caches_len = caches.fn_resolution_caches_len();
 
         #[cfg(not(feature = "no_module"))]
-        let orig_constants = _environ.map(|environ| {
+        let orig_constants = _env.map(|environ| {
             let EncapsulatedEnviron {
                 lib,
                 imports,
@@ -144,8 +144,7 @@ impl Engine {
                 _ => Err(ERR::ErrorInFunctionCall(
                     fn_def.name.to_string(),
                     #[cfg(not(feature = "no_module"))]
-                    _environ
-                        .and_then(|environ| environ.lib.id())
+                    _env.and_then(|env| env.lib.id())
                         .unwrap_or_else(|| global.source().unwrap_or(""))
                         .to_string(),
                     #[cfg(feature = "no_module")]
diff --git a/src/module/mod.rs b/src/module/mod.rs
@@ -2350,7 +2350,8 @@ impl Module {
         let _ = result?;
 
         // Encapsulated environment
-        let environ = Shared::new(crate::ast::EncapsulatedEnviron {
+        #[cfg(not(feature = "no_function"))]
+        let env = Shared::new(crate::ast::EncapsulatedEnviron {
             #[cfg(not(feature = "no_function"))]
             lib: ast.shared_lib().clone(),
             imports,
@@ -2363,17 +2364,18 @@ impl Module {
         while i > 0 {
             i -= 1;
 
-            let (mut value, mut aliases) = if i >= orig_scope_len {
+            let (mut _value, mut aliases) = if i >= orig_scope_len {
                 let (_, v, a) = scope.pop_entry().unwrap();
                 (v, a)
             } else {
                 let (_, v, a) = scope.get_entry_by_index(i);
                 (v.clone(), a.to_vec())
             };
 
-            value.deep_scan(|v| {
+            #[cfg(not(feature = "no_function"))]
+            _value.deep_scan(|v| {
                 if let Some(fn_ptr) = v.downcast_mut::<crate::FnPtr>() {
-                    fn_ptr.environ = Some(environ.clone());
+                    fn_ptr.env = Some(env.clone());
                 }
             });
 
@@ -2382,7 +2384,7 @@ impl Module {
                 1 => {
                     let alias = aliases.pop().unwrap();
                     if !module.contains_var(&alias) {
-                        module.set_var(alias, value);
+                        module.set_var(alias, _value);
                     }
                 }
                 _ => {
@@ -2396,12 +2398,12 @@ impl Module {
                         if first_alias.is_none() {
                             first_alias = Some(alias);
                         } else {
-                            module.set_var(alias, value.clone());
+                            module.set_var(alias, _value.clone());
                         }
                     }
 
                     if let Some(alias) = first_alias {
-                        module.set_var(alias, value);
+                        module.set_var(alias, _value);
                     }
                 }
             }
@@ -2416,15 +2418,11 @@ impl Module {
             })
             .for_each(|f| {
                 let hash = module.set_script_fn(f.clone());
-                if let (
-                    RhaiFunc::Script {
-                        environ: ref mut e, ..
-                    },
-                    _,
-                ) = module.functions.as_mut().unwrap().get_mut(&hash).unwrap()
+                if let (RhaiFunc::Script { env: ref mut e, .. }, _) =
+                    module.functions.as_mut().unwrap().get_mut(&hash).unwrap()
                 {
                     // Encapsulate AST environment
-                    *e = Some(environ.clone());
+                    *e = Some(env.clone());
                 }
             });
 
diff --git a/src/packages/array_basic.rs b/src/packages/array_basic.rs
@@ -4,6 +4,7 @@ use crate::api::deprecated::deprecated_array_functions;
 use crate::engine::OP_EQUALS;
 use crate::eval::{calc_index, calc_offset_len};
 use crate::plugin::*;
+use crate::types::fn_ptr::FnPtrType;
 use crate::{
     def_package, Array, Dynamic, ExclusiveRange, FnPtr, InclusiveRange, NativeCallContext,
     Position, RhaiResultOf, ERR, INT, MAX_USIZE_INT,
@@ -1271,9 +1272,9 @@ pub mod array_functions {
         let comparer = FnPtr {
             name: ctx.engine().get_interned_string(OP_EQUALS),
             curry: <_>::default(),
-            environ: None,
             #[cfg(not(feature = "no_function"))]
-            fn_def: None,
+            env: None,
+            typ: FnPtrType::Normal,
         };
         dedup_by_comparer(ctx, array, comparer);
     }
diff --git a/src/parser.rs b/src/parser.rs
@@ -3677,6 +3677,7 @@ impl Engine {
         skip_parameters: bool,
     ) -> ParseResult<Expr> {
         // Build new parse state
+
         let new_state = &mut ParseState::new(
             state.external_constants,
             state.input,
@@ -3810,9 +3811,9 @@ impl Engine {
         let fn_ptr = crate::FnPtr {
             name: fn_name,
             curry: ThinVec::new(),
-            environ: None,
             #[cfg(not(feature = "no_function"))]
-            fn_def: Some(fn_def.clone()),
+            env: None,
+            typ: crate::types::fn_ptr::FnPtrType::Normal,
         };
 
         let expr = Expr::DynamicConstant(Box::new(fn_ptr.into()), new_settings.pos);
diff --git a/src/tests.rs b/src/tests.rs
@@ -71,8 +71,8 @@ fn check_struct_sizes() {
     assert_eq!(size_of::<Scope>(), 24);
     assert_eq!(
         size_of::<FnPtr>(),
-        32 - if cfg!(feature = "no_function") {
-            WORD_SIZE
+        48 - if cfg!(feature = "no_function") {
+            2 * WORD_SIZE
         } else {
             0
         }
diff --git a/src/types/dynamic.rs b/src/types/dynamic.rs
@@ -406,7 +406,8 @@ impl Hash for Dynamic {
             Union::Blob(ref a, ..) => a.hash(state),
             #[cfg(not(feature = "no_object"))]
             Union::Map(ref m, ..) => m.hash(state),
-            Union::FnPtr(ref f, ..) if f.environ.is_some() => {
+            #[cfg(not(feature = "no_function"))]
+            Union::FnPtr(ref f, ..) if f.env.is_some() => {
                 unimplemented!("FnPtr with embedded environment cannot be hashed")
             }
             Union::FnPtr(ref f, ..) => {
@@ -789,11 +790,7 @@ impl fmt::Debug for Dynamic {
                         Union::FnPtr(ref fnptr, ..) => {
                             dict.insert(value);
 
-                            f.write_str("Fn")?;
-                            #[cfg(not(feature = "no_function"))]
-                            if fnptr.fn_def.is_some() {
-                                f.write_str("*")?;
-                            }
+                            fmt::Display::fmt(&fnptr.typ, f)?;
                             f.write_str("(")?;
                             fmt::Debug::fmt(fnptr.fn_name(), f)?;
                             for curry in &fnptr.curry {
@@ -1220,9 +1217,9 @@ impl Dynamic {
             Union::Blob(..) => true,
             #[cfg(not(feature = "no_object"))]
             Union::Map(ref m, ..) => m.values().all(Self::is_hashable),
-            Union::FnPtr(ref f, ..) => {
-                f.environ.is_none() && f.curry().iter().all(Self::is_hashable)
-            }
+            #[cfg(not(feature = "no_function"))]
+            Union::FnPtr(ref f, ..) if f.env.is_some() => false,
+            Union::FnPtr(ref f, ..) => f.curry().iter().all(Self::is_hashable),
             #[cfg(not(feature = "no_time"))]
             Union::TimeStamp(..) => false,
 
@@ -1297,7 +1294,7 @@ impl Dynamic {
                         #[cfg(not(feature = "no_object"))]
                         Union::Map(ref m, ..) => m.values().all(|v| checked_is_hashable(v, dict)),
                         Union::FnPtr(ref f, ..) => {
-                            f.environ.is_none()
+                            f.env.is_none()
                                 && f.curry().iter().all(|v| checked_is_hashable(v, dict))
                         }
                         _ => value.is_hashable(),
diff --git a/src/types/fn_ptr.rs b/src/types/fn_ptr.rs
diff --git a/tests/fn_ptr.rs b/tests/fn_ptr.rs

Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ pub enum RhaiFunc {`
`56`	`56`	/// Shared reference to the [`ScriptFuncDef`][crate::ast::ScriptFuncDef] function definition.
`57`	`57`	`fn_def: Shared<crate::ast::ScriptFuncDef>,`
`58`	`58`	`/// Encapsulated environment, if any.`
`59`		`- environ: Option<Shared<EncapsulatedEnviron>>,`
	`59`	`+ env: Option<Shared<EncapsulatedEnviron>>,`
`60`	`60`	`},`
`61`	`61`	`}`
`62`	`62`
`@@ -262,7 +262,7 @@ impl RhaiFunc {`
`262`	`262`	`\| Self::Plugin { .. } => None,`
`263`	`263`
`264`	`264`	`#[cfg(not(feature = "no_function"))]`
`265`		`- Self::Script { environ, .. } => environ.as_deref(),`
	`265`	`+ Self::Script { env, .. } => env.as_deref(),`
`266`	`266`	`}`
`267`	`267`	`}`
`268`	`268`	`/// Get a reference to an iterator function.`
`@@ -297,7 +297,7 @@ impl From<crate::ast::ScriptFuncDef> for RhaiFunc {`
`297`	`297`	`fn from(fn_def: crate::ast::ScriptFuncDef) -> Self {`
`298`	`298`	`Self::Script {`
`299`	`299`	`fn_def: fn_def.into(),`
`300`		`- environ: None,`
	`300`	`+ env: None,`
`301`	`301`	`}`
`302`	`302`	`}`
`303`	`303`	`}`
`@@ -306,10 +306,7 @@ impl From<crate::ast::ScriptFuncDef> for RhaiFunc {`
`306`	`306`	`impl From<Shared<crate::ast::ScriptFuncDef>> for RhaiFunc {`
`307`	`307`	`#[inline(always)]`
`308`	`308`	`fn from(fn_def: Shared<crate::ast::ScriptFuncDef>) -> Self {`
`309`		`- Self::Script {`
`310`		`- fn_def,`
`311`		`- environ: None,`
`312`		`- }`
	`309`	`+ Self::Script { fn_def, env: None }`
`313`	`310`	`}`
`314`	`311`	`}`
`315`	`312`
Original file line number	Diff line number	Diff line change
`@@ -71,8 +71,8 @@ fn check_struct_sizes() {`
`71`	`71`	`assert_eq!(size_of::<Scope>(), 24);`
`72`	`72`	`assert_eq!(`
`73`	`73`	`size_of::<FnPtr>(),`
`74`		`- 32 - if cfg!(feature = "no_function") {`
`75`		`- WORD_SIZE`
	`74`	`+ 48 - if cfg!(feature = "no_function") {`
	`75`	`+ 2 * WORD_SIZE`
`76`	`76`	`} else {`
`77`	`77`	`0`
`78`	`78`	`}`