Merge pull request #1063 from schungx/master

Change instant to web-time for WASM targets.

Author: schungx

CHANGELOG.md

@@ -8,6 +8,7 @@ Breaking Changes
 ----------------
 
 * `stdweb` support is removed. The feature flag `stdweb` is also removed. Use `wasm-bindgen` instead.
+* [`web-time`](https://crates.io/crates/web-time) is used for WASM targets instead of [`instant`](https://crates.io/crates/instant), which is no longer maintained.
 
 Bug fixes
 ---------
@@ -23,6 +24,11 @@ Enhancements
 * The methods `sort_desc`, `order`, `order_by` and `order_desc` are added to arrays.
 * An exception is now thrown when attempting to use `sort` on an array containing unsupported element types.
 
+New features
+------------
+
+* `AST::new_from_module` is added to create an `AST` from a shared `Module`.
+
 
 Version 1.23.6
 ==============

Cargo.toml

@@ -118,7 +118,7 @@ no_std = ["no-std-compat", "num-traits/libm", "core-error", "libm", "hashbrown",
 #! ### JavaScript Interface for WASM
 
 ## Use [`wasm-bindgen`](https://crates.io/crates/wasm-bindgen) as JavaScript interface.
-wasm-bindgen = ["getrandom/wasm_js", "instant/wasm-bindgen"]
+wasm-bindgen = ["getrandom/wasm_js"]
 
 #! ### Features used in testing environments only
 
@@ -154,7 +154,7 @@ codegen-units = 1
 #panic = 'abort'     # remove stack backtrace for no-std
 
 [target.'cfg(target_family = "wasm")'.dependencies]
-instant = { version = "0.1.10" } # WASM implementation of std::time::Instant
+web-time = { version = "1.1.0" } # WASM implementation of std::time::Instant
 
 [package.metadata.docs.rs]
 features = ["document-features", "metadata", "serde", "internals", "decimal", "debugging"]
@@ -163,6 +163,3 @@ features = ["document-features", "metadata", "serde", "internals", "decimal", "d
 # Notice that a custom modified version of `rustyline` is used which supports bracketed paste on Windows.
 # This can be moved to the official version when bracketed paste is added.
 rustyline = { git = "https://github.com/schungx/rustyline", branch = "v15_fake" }
-
-# Patch SmartString to resolve an UB issue.
-#smartstring = { git = "https://github.com/bodil/smartstring", ref = "refs/pull/34/head" }

README.md

@@ -32,11 +32,8 @@ Targets and builds
 Versions
 --------
 
-The [`ahash`](https://crates.io/crates/ahash) crate that Rhai depends on has a breaking change since version `0.8.12` which bumps [`getrandom`](https://crates.io/crates/getrandom) to version `0.3`, braking certain `no-std` and WASM builds.
-
-Version [`1.23.5`](https://crates.io/crates/rhai/1.23.5): Use this version when building for `no-std` or WASM.
-
-Version [`1.23.6`](https://crates.io/crates/rhai/1.23.6): This is the main version for `std` builds.
+As of this version, [`stdweb`](https://crates.io/crates/stdweb) is no longer supported for WASM builds
+because of changes to [`getrandom`](https://crates.io/crates/getrandom) starting from version 0.3.
 
 
 Standard features

codegen/src/custom_type.rs

@@ -197,18 +197,14 @@ fn extract_type_from_option(ty: &syn::Type) -> Option<&syn::Type> {
     // 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
-            });
+        let idents_of_path = path.segments.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)
+            .find(|s| idents_of_path == *s)
             .and_then(|_| path.segments.last())
     }
 
@@ -368,7 +364,7 @@ fn scan_fields(fields: &[&Field], accessors: &mut Vec<TokenStream>, errors: &mut
             (Some(func), _) => func,
             (None, Some(func)) => quote! { |obj: &mut Self| #func(&*obj) },
             (None, None) => {
-                if let Some(_) = option_type {
+                if option_type.is_some() {
                     quote! { |obj: &mut Self| obj.#field_name.clone().map_or(Dynamic::UNIT, Dynamic::from) }
                 } else {
                     quote! { |obj: &mut Self| obj.#field_name.clone() }

src/api/call_fn.rs

@@ -22,7 +22,7 @@ pub struct CallFnOptions<'t> {
     pub eval_ast: bool,
     /// Rewind the [`Scope`] after the function call? Default `true`.
     pub rewind_scope: bool,
-    /// Call only scripted functions from the [`AST`] instead of functions in all namespaces.
+    /// Call functions in all namespaces instead of only scripted functions within the [`AST`].
     pub in_all_namespaces: bool,
 }
 
@@ -77,7 +77,7 @@ impl<'a> CallFnOptions<'a> {
     /// Call functions in all namespaces instead of only scripted functions within the [`AST`].
     #[inline(always)]
     #[must_use]
-    pub fn in_all_namespaces(mut self, value: bool) -> Self {
+    pub const fn in_all_namespaces(mut self, value: bool) -> Self {
         self.in_all_namespaces = value;
         self
     }
@@ -291,12 +291,10 @@ impl Engine {
             } else if !in_all_namespaces {
                 Err(ERR::ErrorFunctionNotFound(name.into(), Position::NONE).into())
             } else {
-                let has_this = if let Some(this_ptr) = this_ptr.as_deref_mut() {
+                let has_this = this_ptr.as_deref_mut().map_or(false, |this_ptr| {
                     args.insert(0, this_ptr);
                     true
-                } else {
-                    false
-                };
+                });
 
                 self.eval_fn_call_with_arguments::<Dynamic>(name, args, has_this, has_this)
             }

src/api/definitions/mod.rs

@@ -490,16 +490,19 @@ impl FuncMetadata {
             }
             first = false;
 
-            let (param_name, param_type) = self.params_info.get(i).map_or(("_", "?".into()), |s| {
-                let (name, typ) = s.split_once(':').unwrap_or((s, ""));
-                (
-                    name.trim().split(' ').last().unwrap().trim(),
-                    match typ.trim() {
-                        "" | "?" | "_" => "?".into(),
-                        typ => def_type_name(typ, def.engine),
-                    },
-                )
-            });
+            let (param_name, param_type) = self.params_info.get(i).map_or_else(
+                || ("_", "?".into()),
+                |s| {
+                    let (name, typ) = s.split_once(':').unwrap_or((s, ""));
+                    (
+                        name.trim().split(' ').next_back().unwrap().trim(),
+                        match typ.trim() {
+                            "" | "?" | "_" => "?".into(),
+                            typ => def_type_name(typ, def.engine),
+                        },
+                    )
+                },
+            );
 
             if operator {
                 write!(writer, "{param_type}")?;

src/api/eval.rs

@@ -335,15 +335,15 @@ impl Engine {
     pub fn eval_fn_call<T: Variant + Clone>(
         &self,
         fn_name: impl AsRef<str>,
-        mut this_ptr: Option<&mut Dynamic>,
+        this_ptr: Option<&mut Dynamic>,
         args: impl FuncArgs,
     ) -> RhaiResultOf<T> {
         let mut has_this = false;
         let arg_values = &mut FnArgsVec::new_const();
         args.parse(arg_values);
         let args = &mut arg_values.iter_mut().collect::<FnArgsVec<_>>();
 
-        if let Some(this_ptr) = this_ptr.as_deref_mut() {
+        if let Some(this_ptr) = this_ptr {
             args.insert(0, this_ptr);
             has_this = true;
         }

src/api/files.rs

@@ -41,7 +41,7 @@ impl Engine {
                 }
                 None => contents.clear(),
             }
-        };
+        }
 
         Ok(contents)
     }

src/ast/ast.rs

@@ -104,9 +104,23 @@ impl AST {
         ast.set_source(source);
         ast
     }
-    /// Create an empty [`AST`].
+    /// Create a new [`AST`] from a shared [`Module`][crate::Module].
+    #[cfg(not(feature = "no_function"))]
     #[inline]
     #[must_use]
+    pub fn new_from_module(module: impl Into<crate::SharedModule>) -> Self {
+        let module = module.into();
+
+        if let Some(source) = module.id() {
+            let source: crate::SmartString = source.into();
+            Self::new_with_source(std::iter::empty(), module, source)
+        } else {
+            Self::new(std::iter::empty(), module)
+        }
+    }
+    /// Create an empty [`AST`].
+    #[inline(always)]
+    #[must_use]
     pub fn empty() -> Self {
         Self {
             source: None,

src/ast/expr.rs

@@ -234,7 +234,7 @@ impl FnCallExpr {
     /// Is this function call an operator expression?
     #[inline(always)]
     #[must_use]
-    pub fn is_operator_call(&self) -> bool {
+    pub const fn is_operator_call(&self) -> bool {
         self.op_token.is_some()
     }
     /// Convert this into an [`Expr::FnCall`].
@@ -276,12 +276,12 @@ pub enum Expr {
     /// [String][ImmutableString] constant.
     StringConstant(ImmutableString, Position),
     /// An interpolated [string][ImmutableString].
-    InterpolatedString(ThinVec<Expr>, Position),
+    InterpolatedString(ThinVec<Self>, Position),
     /// [ expr, ... ]
-    Array(ThinVec<Expr>, Position),
+    Array(ThinVec<Self>, Position),
     /// #{ name:expr, ... }
     Map(
-        Box<(StaticVec<(Ident, Expr)>, BTreeMap<Identifier, Dynamic>)>,
+        Box<(StaticVec<(Ident, Self)>, BTreeMap<Identifier, Dynamic>)>,
         Position,
     ),
     /// ()
@@ -330,11 +330,11 @@ pub enum Expr {
     /// * [`BREAK`][ASTFlags::BREAK] = terminate the chain (recurse into the chain if unset)
     Index(Box<BinaryExpr>, ASTFlags, Position),
     /// lhs `&&` rhs
-    And(Box<StaticVec<Expr>>, Position),
+    And(Box<StaticVec<Self>>, Position),
     /// lhs `||` rhs
-    Or(Box<StaticVec<Expr>>, Position),
+    Or(Box<StaticVec<Self>>, Position),
     /// lhs `??` rhs
-    Coalesce(Box<StaticVec<Expr>>, Position),
+    Coalesce(Box<StaticVec<Self>>, Position),
     /// Custom syntax
     #[cfg(not(feature = "no_custom_syntax"))]
     Custom(Box<CustomExpr>, Position),
@@ -764,7 +764,7 @@ impl Expr {
             Self::Map(x, ..) => x.0.iter().map(|(.., v)| v).all(Self::is_pure),
 
             Self::And(x, ..) | Self::Or(x, ..) | Self::Coalesce(x, ..) => {
-                x.iter().all(Expr::is_pure)
+                x.iter().all(Self::is_pure)
             }
 
             Self::Stmt(x) => x.iter().all(Stmt::is_pure),