kjuulh/rhai
1
0
Fork 0
Code Issues 1 Pull Requests 1 Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'other/master' into type_builder_iterable

Browse Source
This commit is contained in:
Tristan Guichaoua 2022-08-10 17:31:17 +02:00
commit 24bf3c29ef
5 changed files with 94 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
CHANGELOG.md
View File

@ -13,6 +13,7 @@ Bug fixes
* Fixes concatenation of BLOB's and strings, where the BLOB's should be interpreted as UTF-8 encoded strings. * Fixes concatenation of BLOB's and strings, where the BLOB's should be interpreted as UTF-8 encoded strings.
* Capturing an unknown variable in a closure no longer panics. * Capturing an unknown variable in a closure no longer panics.
* Fixes panic in interpolated strings with constant expressions. * Fixes panic in interpolated strings with constant expressions.
* Using `call_fn_raw` on a function without evaluating the AST no longer panics on namespace-qualified function calls due to `import` statements not run.
New features New features
------------ ------------
@ -38,6 +39,10 @@ New features
* Crate-level functions `rhai::eval`, `rhai::run`, `rhai::eval_file`, `rhai::run_file` are added as convenient wrappers. * Crate-level functions `rhai::eval`, `rhai::run`, `rhai::eval_file`, `rhai::run_file` are added as convenient wrappers.
### CustomType trait and TypeBuilder
* A new volatile API, `Engine::build_type`, enables registration of the entire API of a custom type in one go, provided that the custom type implements the `CustomType` trait (which uses `TypeBuilder` to register the API functions).
Enhancements Enhancements
------------ ------------

18
examples/custom_types.rs
View File

@ -32,6 +32,15 @@ fn main() -> Result<(), Box<EvalAltResult>> {
} }
} }
impl IntoIterator for TestStruct {
type Item = i64;
type IntoIter = std::vec::IntoIter<Self::Item>;
fn into_iter(self) -> Self::IntoIter {
vec![self.x - 1, self.x, self.x + 1].into_iter()
}
}
impl CustomType for TestStruct { impl CustomType for TestStruct {
fn build(mut builder: TypeBuilder<Self>) { fn build(mut builder: TypeBuilder<Self>) {
#[allow(deprecated)] // The TypeBuilder api is volatile. #[allow(deprecated)] // The TypeBuilder api is volatile.
@ -40,6 +49,7 @@ fn main() -> Result<(), Box<EvalAltResult>> {
.with_fn("new_ts", Self::new) .with_fn("new_ts", Self::new)
.with_fn("update", Self::update) .with_fn("update", Self::update)
.with_fn("calc", Self::calculate) .with_fn("calc", Self::calculate)
.is_iterable()
.with_get_set("x", Self::get_x, Self::set_x); .with_get_set("x", Self::get_x, Self::set_x);
} }
} }
@ -63,8 +73,16 @@ fn main() -> Result<(), Box<EvalAltResult>> {
let result = engine.eval::<i64>( let result = engine.eval::<i64>(
" "
let x = new_ts(); let x = new_ts();
x.x = 42; x.x = 42;
for n in x {
x.x += n;
print(`n = ${n}, total = ${x.x}`);
}
x.update(); x.update();
x.calc(x.x) x.calc(x.x)
", ",
)?; )?;

80
src/api/build_type.rs
View File

@ -1,17 +1,18 @@
//! Trait to build a custom type for use with [`Engine`]. //! Trait to build a custom type for use with [`Engine`].
#![allow(deprecated)] #![allow(deprecated)]
use crate::{ use crate::{types::dynamic::Variant, Engine, Identifier, RegisterNativeFunction, RhaiResultOf};
func::SendSync, types::dynamic::Variant, Engine, Identifier, RegisterNativeFunction,
RhaiResultOf,
};
use std::marker::PhantomData; use std::marker::PhantomData;
#[cfg(feature = "no_std")] #[cfg(feature = "no_std")]
use std::prelude::v1::*; use std::prelude::v1::*;
/// Trait to build a custom type for use with an [`Engine`] /// Trait to build the API of a custom type for use with an [`Engine`]
/// (i.e. register the type and its getters, setters, methods, etc.). /// (i.e. register the type and its getters, setters, methods, etc.).
/// ///
/// # WARNING - Volatile Trait
///
/// This API is volatile and may change in the future.
///
/// # Example /// # Example
/// ///
/// ``` /// ```
@ -71,9 +72,13 @@ pub trait CustomType: Variant + Clone {
} }
impl Engine { impl Engine {
/// Build a custom type for use with the [`Engine`]. /// Build the API of a custom type for use with the [`Engine`].
/// ///
/// The custom type must implement [`CustomType`]. /// The custom type must implement [`CustomType`].
///
/// # WARNING - Unstable API
///
/// This API is volatile and may change in the future.
#[inline] #[inline]
pub fn build_type<T: CustomType>(&mut self) -> &mut Self { pub fn build_type<T: CustomType>(&mut self) -> &mut Self {
T::build(TypeBuilder::new(self)); T::build(TypeBuilder::new(self));
@ -81,15 +86,15 @@ impl Engine {
} }
} }
/// Builder to build a custom type for use with an [`Engine`]. /// Builder to build the API of a custom type for use with an [`Engine`].
/// ///
/// The type is automatically registered when this builder is dropped. /// The type is automatically registered when this builder is dropped.
/// ///
/// ## Pretty name /// ## Pretty-Print Name
/// ///
/// By default the type is registered with [`Engine::register_type`] (i.e. without a pretty name). /// By default the type is registered with [`Engine::register_type`] (i.e. without a pretty-print name).
/// ///
/// To define a pretty name, call [`with_name`][`TypeBuilder::with_name`], /// To define a pretty-print name, call [`with_name`][`TypeBuilder::with_name`],
/// to use [`Engine::register_type_with_name`] instead. /// to use [`Engine::register_type_with_name`] instead.
#[deprecated = "This type is NOT deprecated, but it is considered volatile and may change in the future."] #[deprecated = "This type is NOT deprecated, but it is considered volatile and may change in the future."]
pub struct TypeBuilder<'a, T: Variant + Clone> { pub struct TypeBuilder<'a, T: Variant + Clone> {
@ -99,6 +104,7 @@ pub struct TypeBuilder<'a, T: Variant + Clone> {
} }
impl<'a, T: Variant + Clone> TypeBuilder<'a, T> { impl<'a, T: Variant + Clone> TypeBuilder<'a, T> {
/// Create a [`TypeBuilder`] linked to a particular [`Engine`] instance.
#[inline(always)] #[inline(always)]
fn new(engine: &'a mut Engine) -> Self { fn new(engine: &'a mut Engine) -> Self {
Self { Self {
@ -110,7 +116,7 @@ impl<'a, T: Variant + Clone> TypeBuilder<'a, T> {
} }
impl<'a, T: Variant + Clone> TypeBuilder<'a, T> { impl<'a, T: Variant + Clone> TypeBuilder<'a, T> {
/// Sets a pretty-print name for the `type_of` function. /// Set a pretty-print name for the `type_of` function.
#[inline(always)] #[inline(always)]
pub fn with_name(&mut self, name: &'static str) -> &mut Self { pub fn with_name(&mut self, name: &'static str) -> &mut Self {
self.name = Some(name); self.name = Some(name);
@ -140,6 +146,20 @@ impl<'a, T: Variant + Clone> TypeBuilder<'a, T> {
} }
} }
impl<'a, T> TypeBuilder<'a, T>
where
T: Variant + Clone + IntoIterator,
<T as IntoIterator>::Item: Variant + Clone,
{
/// Register a type iterator.
/// This is an advanced API.
#[inline(always)]
pub fn is_iterable(&mut self) -> &mut Self {
self.engine.register_iterator::<T>();
self
}
}
#[cfg(not(feature = "no_object"))] #[cfg(not(feature = "no_object"))]
impl<'a, T: Variant + Clone> TypeBuilder<'a, T> { impl<'a, T: Variant + Clone> TypeBuilder<'a, T> {
/// Register a getter function. /// Register a getter function.
@ -151,7 +171,7 @@ impl<'a, T: Variant + Clone> TypeBuilder<'a, T> {
pub fn with_get<V: Variant + Clone>( pub fn with_get<V: Variant + Clone>(
&mut self, &mut self,
name: impl AsRef<str>, name: impl AsRef<str>,
get_fn: impl Fn(&mut T) -> V + SendSync + 'static, get_fn: impl Fn(&mut T) -> V + crate::func::SendSync + 'static,
) -> &mut Self { ) -> &mut Self {
self.engine.register_get(name, get_fn); self.engine.register_get(name, get_fn);
self self
@ -166,7 +186,7 @@ impl<'a, T: Variant + Clone> TypeBuilder<'a, T> {
pub fn with_get_result<V: Variant + Clone>( pub fn with_get_result<V: Variant + Clone>(
&mut self, &mut self,
name: impl AsRef<str>, name: impl AsRef<str>,
get_fn: impl Fn(&mut T) -> RhaiResultOf<V> + SendSync + 'static, get_fn: impl Fn(&mut T) -> RhaiResultOf<V> + crate::func::SendSync + 'static,
) -> &mut Self { ) -> &mut Self {
self.engine.register_get_result(name, get_fn); self.engine.register_get_result(name, get_fn);
self self
@ -179,7 +199,7 @@ impl<'a, T: Variant + Clone> TypeBuilder<'a, T> {
pub fn with_set<V: Variant + Clone>( pub fn with_set<V: Variant + Clone>(
&mut self, &mut self,
name: impl AsRef<str>, name: impl AsRef<str>,
set_fn: impl Fn(&mut T, V) + SendSync + 'static, set_fn: impl Fn(&mut T, V) + crate::func::SendSync + 'static,
) -> &mut Self { ) -> &mut Self {
self.engine.register_set(name, set_fn); self.engine.register_set(name, set_fn);
self self
@ -192,7 +212,7 @@ impl<'a, T: Variant + Clone> TypeBuilder<'a, T> {
pub fn with_set_result<V: Variant + Clone>( pub fn with_set_result<V: Variant + Clone>(
&mut self, &mut self,
name: impl AsRef<str>, name: impl AsRef<str>,
set_fn: impl Fn(&mut T, V) -> RhaiResultOf<()> + SendSync + 'static, set_fn: impl Fn(&mut T, V) -> RhaiResultOf<()> + crate::func::SendSync + 'static,
) -> &mut Self { ) -> &mut Self {
self.engine.register_set_result(name, set_fn); self.engine.register_set_result(name, set_fn);
self self
@ -207,8 +227,8 @@ impl<'a, T: Variant + Clone> TypeBuilder<'a, T> {
pub fn with_get_set<V: Variant + Clone>( pub fn with_get_set<V: Variant + Clone>(
&mut self, &mut self,
name: impl AsRef<str>, name: impl AsRef<str>,
get_fn: impl Fn(&mut T) -> V + SendSync + 'static, get_fn: impl Fn(&mut T) -> V + crate::func::SendSync + 'static,
set_fn: impl Fn(&mut T, V) + SendSync + 'static, set_fn: impl Fn(&mut T, V) + crate::func::SendSync + 'static,
) -> &mut Self { ) -> &mut Self {
self.engine.register_get_set(name, get_fn, set_fn); self.engine.register_get_set(name, get_fn, set_fn);
self self
@ -225,7 +245,7 @@ impl<'a, T: Variant + Clone> TypeBuilder<'a, T> {
#[inline(always)] #[inline(always)]
pub fn with_indexer_get<X: Variant + Clone, V: Variant + Clone>( pub fn with_indexer_get<X: Variant + Clone, V: Variant + Clone>(
&mut self, &mut self,
get_fn: impl Fn(&mut T, X) -> V + SendSync + 'static, get_fn: impl Fn(&mut T, X) -> V + crate::func::SendSync + 'static,
) -> &mut Self { ) -> &mut Self {
self.engine.register_indexer_get(get_fn); self.engine.register_indexer_get(get_fn);
self self
@ -239,7 +259,7 @@ impl<'a, T: Variant + Clone> TypeBuilder<'a, T> {
#[inline(always)] #[inline(always)]
pub fn with_indexer_get_result<X: Variant + Clone, V: Variant + Clone>( pub fn with_indexer_get_result<X: Variant + Clone, V: Variant + Clone>(
&mut self, &mut self,
get_fn: impl Fn(&mut T, X) -> RhaiResultOf<V> + SendSync + 'static, get_fn: impl Fn(&mut T, X) -> RhaiResultOf<V> + crate::func::SendSync + 'static,
) -> &mut Self { ) -> &mut Self {
self.engine.register_indexer_get_result(get_fn); self.engine.register_indexer_get_result(get_fn);
self self
@ -251,7 +271,7 @@ impl<'a, T: Variant + Clone> TypeBuilder<'a, T> {
#[inline(always)] #[inline(always)]
pub fn with_indexer_set<X: Variant + Clone, V: Variant + Clone>( pub fn with_indexer_set<X: Variant + Clone, V: Variant + Clone>(
&mut self, &mut self,
set_fn: impl Fn(&mut T, X, V) + SendSync + 'static, set_fn: impl Fn(&mut T, X, V) + crate::func::SendSync + 'static,
) -> &mut Self { ) -> &mut Self {
self.engine.register_indexer_set(set_fn); self.engine.register_indexer_set(set_fn);
self self
@ -263,7 +283,7 @@ impl<'a, T: Variant + Clone> TypeBuilder<'a, T> {
#[inline(always)] #[inline(always)]
pub fn with_indexer_set_result<X: Variant + Clone, V: Variant + Clone>( pub fn with_indexer_set_result<X: Variant + Clone, V: Variant + Clone>(
&mut self, &mut self,
set_fn: impl Fn(&mut T, X, V) -> RhaiResultOf<()> + SendSync + 'static, set_fn: impl Fn(&mut T, X, V) -> RhaiResultOf<()> + crate::func::SendSync + 'static,
) -> &mut Self { ) -> &mut Self {
self.engine.register_indexer_set_result(set_fn); self.engine.register_indexer_set_result(set_fn);
self self
@ -275,28 +295,14 @@ impl<'a, T: Variant + Clone> TypeBuilder<'a, T> {
#[inline(always)] #[inline(always)]
pub fn with_indexer_get_set<X: Variant + Clone, V: Variant + Clone>( pub fn with_indexer_get_set<X: Variant + Clone, V: Variant + Clone>(
&mut self, &mut self,
get_fn: impl Fn(&mut T, X) -> V + SendSync + 'static, get_fn: impl Fn(&mut T, X) -> V + crate::func::SendSync + 'static,
set_fn: impl Fn(&mut T, X, V) + SendSync + 'static, set_fn: impl Fn(&mut T, X, V) + crate::func::SendSync + 'static,
) -> &mut Self { ) -> &mut Self {
self.engine.register_indexer_get_set(get_fn, set_fn); self.engine.register_indexer_get_set(get_fn, set_fn);
self self
} }
} }
impl<'a, T> TypeBuilder<'a, T>
where
T: Variant + Clone + IntoIterator,
<T as IntoIterator>::Item: Variant + Clone,
{
/// Register an type iterator.
/// This is an advanced API.
#[inline(always)]
pub fn is_iterable(&mut self) -> &mut Self {
self.engine.register_iterator::<T>();
self
}
}
impl<'a, T: Variant + Clone> Drop for TypeBuilder<'a, T> { impl<'a, T: Variant + Clone> Drop for TypeBuilder<'a, T> {
#[inline] #[inline]
fn drop(&mut self) { fn drop(&mut self) {

28
src/parser.rs
View File

@ -72,6 +72,9 @@ pub struct ParseState<'e> {
/// Encapsulates a local stack with imported [module][crate::Module] names. /// Encapsulates a local stack with imported [module][crate::Module] names.
#[cfg(not(feature = "no_module"))] #[cfg(not(feature = "no_module"))]
pub imports: StaticVec<Identifier>, pub imports: StaticVec<Identifier>,
/// List of globally-imported [module][crate::Module] names.
#[cfg(not(feature = "no_module"))]
pub global_imports: StaticVec<Identifier>,
/// Maximum levels of expression nesting (0 for unlimited). /// Maximum levels of expression nesting (0 for unlimited).
#[cfg(not(feature = "unchecked"))] #[cfg(not(feature = "unchecked"))]
pub max_expr_depth: usize, pub max_expr_depth: usize,
@ -91,7 +94,8 @@ impl fmt::Debug for ParseState<'_> {
f.field("external_vars", &self.external_vars) f.field("external_vars", &self.external_vars)
.field("allow_capture", &self.allow_capture); .field("allow_capture", &self.allow_capture);
#[cfg(not(feature = "no_module"))] #[cfg(not(feature = "no_module"))]
f.field("imports", &self.imports); f.field("imports", &self.imports)
.field("global_imports", &self.global_imports);
#[cfg(not(feature = "unchecked"))] #[cfg(not(feature = "unchecked"))]
f.field("max_expr_depth", &self.max_expr_depth); f.field("max_expr_depth", &self.max_expr_depth);
f.finish() f.finish()
@ -117,6 +121,8 @@ impl<'e> ParseState<'e> {
block_stack_len: 0, block_stack_len: 0,
#[cfg(not(feature = "no_module"))] #[cfg(not(feature = "no_module"))]
imports: StaticVec::new_const(), imports: StaticVec::new_const(),
#[cfg(not(feature = "no_module"))]
global_imports: StaticVec::new_const(),
#[cfg(not(feature = "unchecked"))] #[cfg(not(feature = "unchecked"))]
max_expr_depth: engine.max_expr_depth(), max_expr_depth: engine.max_expr_depth(),
} }
@ -557,6 +563,7 @@ impl Engine {
if settings.options.contains(LangOptions::STRICT_VAR) if settings.options.contains(LangOptions::STRICT_VAR)
&& index.is_none() && index.is_none()
&& !is_global && !is_global
&& !state.global_imports.iter().any(|m| m == root)
&& !self.global_sub_modules.contains_key(root) && !self.global_sub_modules.contains_key(root)
{ {
return Err( return Err(
@ -624,6 +631,7 @@ impl Engine {
if settings.options.contains(LangOptions::STRICT_VAR) if settings.options.contains(LangOptions::STRICT_VAR)
&& index.is_none() && index.is_none()
&& !is_global && !is_global
&& !state.global_imports.iter().any(|m| m == root)
&& !self.global_sub_modules.contains_key(root) && !self.global_sub_modules.contains_key(root)
{ {
return Err(PERR::ModuleUndefined(root.to_string()) return Err(PERR::ModuleUndefined(root.to_string())
@ -1351,7 +1359,10 @@ impl Engine {
ParseState::new(self, state.scope, state.tokenizer_control.clone()); ParseState::new(self, state.scope, state.tokenizer_control.clone());
#[cfg(not(feature = "no_module"))] #[cfg(not(feature = "no_module"))]
new_state.imports.clone_from(&state.imports); {
new_state.imports.clone_from(&state.imports);
new_state.global_imports.clone_from(&state.global_imports);
}
#[cfg(not(feature = "unchecked"))] #[cfg(not(feature = "unchecked"))]
{ {
@ -1789,6 +1800,7 @@ impl Engine {
if settings.options.contains(LangOptions::STRICT_VAR) if settings.options.contains(LangOptions::STRICT_VAR)
&& index.is_none() && index.is_none()
&& !is_global && !is_global
&& !state.global_imports.iter().any(|m| m == root)
&& !self.global_sub_modules.contains_key(root) && !self.global_sub_modules.contains_key(root)
{ {
return Err( return Err(
@ -3204,7 +3216,17 @@ impl Engine {
ParseState::new(self, state.scope, state.tokenizer_control.clone()); ParseState::new(self, state.scope, state.tokenizer_control.clone());
#[cfg(not(feature = "no_module"))] #[cfg(not(feature = "no_module"))]
new_state.imports.clone_from(&state.imports); {
// Do not allow storing an index to a globally-imported module
// just in case the function is separated from this `AST`.
//
// Keep them in `global_imports` instead so that strict variables
// mode will not complain.
new_state.global_imports.clone_from(&state.global_imports);
new_state
.global_imports
.extend(state.imports.iter().cloned());
}
#[cfg(not(feature = "unchecked"))] #[cfg(not(feature = "unchecked"))]
{ {

6
tests/build_type.rs
View File

@ -47,11 +47,10 @@ fn build_type() -> Result<(), Box<EvalAltResult>> {
impl IntoIterator for Vec3 { impl IntoIterator for Vec3 {
type Item = INT; type Item = INT;
type IntoIter = std::vec::IntoIter<Self::Item>;
type IntoIter = std::array::IntoIter<INT, 3>;
fn into_iter(self) -> Self::IntoIter { fn into_iter(self) -> Self::IntoIter {
<[INT; 3] as IntoIterator>::into_iter([self.x, self.y, self.z]) vec![self.x, self.y, self.z].into_iter()
} }
} }
@ -61,6 +60,7 @@ fn build_type() -> Result<(), Box<EvalAltResult>> {
.with_name("Vec3") .with_name("Vec3")
.is_iterable() .is_iterable()
.with_fn("vec3", Self::new) .with_fn("vec3", Self::new)
.is_iterable()
.with_get_set("x", Self::get_x, Self::set_x) .with_get_set("x", Self::get_x, Self::set_x)
.with_get_set("y", Self::get_y, Self::set_y) .with_get_set("y", Self::get_y, Self::set_y)
.with_get_set("z", Self::get_z, Self::set_z); .with_get_set("z", Self::get_z, Self::set_z);