Merge pull request #751 from schungx/master

Code refactor.

.github/workflows/build.yml

@@ -32,6 +32,7 @@ jobs:
       - uses: actions-rs/cargo@v1
         with:
           command: check
+          args: "--features decimal,metadata,serde,debugging"
 
   # typical build with various feature combinations
   build:

codegen/Cargo.toml

@@ -20,7 +20,7 @@ metadata = []
 
 [dependencies]
 proc-macro2 = "1.0.0"
-syn = { version = "1.0.0", features = ["full", "parsing", "printing", "proc-macro", "extra-traits"] }
+syn = { version = "2.0.0", features = ["full", "parsing", "printing", "proc-macro", "extra-traits"] }
 quote = "1.0.0"
 
 [dev-dependencies]

codegen/src/attrs.rs

@@ -12,8 +12,8 @@ pub enum ExportScope {
 }
 
 impl Default for ExportScope {
-    fn default() -> ExportScope {
-        ExportScope::PubOnly
+    fn default() -> Self {
+        Self::PubOnly
     }
 }
 
@@ -118,17 +118,11 @@ pub fn inner_item_attributes<T: ExportedParams>(
     attr_name: &str,
 ) -> syn::Result<T> {
     // Find the #[rhai_fn] attribute which will turn be read for function parameters.
-    if let Some(index) = attrs
-        .iter()
-        .position(|a| a.path.get_ident().map_or(false, |i| *i == attr_name))
-    {
+    if let Some(index) = attrs.iter().position(|a| a.path().is_ident(attr_name)) {
         let rhai_fn_attr = attrs.remove(index);
 
         // Cannot have more than one #[rhai_fn]
-        if let Some(duplicate) = attrs
-            .iter()
-            .find(|a| a.path.get_ident().map_or(false, |i| *i == attr_name))
-        {
+        if let Some(duplicate) = attrs.iter().find(|&a| a.path().is_ident(attr_name)) {
             return Err(syn::Error::new(
                 duplicate.span(),
                 format!("duplicated attribute '{attr_name}'"),
@@ -148,33 +142,37 @@ pub fn doc_attributes(attrs: &[syn::Attribute]) -> syn::Result<Vec<String>> {
     let mut buf = String::new();
 
     for attr in attrs {
-        if let Some(i) = attr.path.get_ident() {
-            if *i == "doc" {
-                if let syn::Meta::NameValue(syn::MetaNameValue {
-                    lit: syn::Lit::Str(s),
+        if !attr.path().is_ident("doc") {
+            continue;
+        }
+
+        if let syn::Meta::NameValue(syn::MetaNameValue {
+            value:
+                syn::Expr::Lit(syn::ExprLit {
+                    lit: syn::Lit::Str(ref s),
                     ..
-                }) = attr.parse_meta()?
-                {
-                    let mut line = s.value();
-
-                    if line.contains('\n') {
-                        // Must be a block comment `/** ... */`
-                        if !buf.is_empty() {
-                            comments.push(buf.clone());
-                            buf.clear();
-                        }
-                        line.insert_str(0, "/**");
-                        line.push_str("*/");
-                        comments.push(line);
-                    } else {
-                        // Single line - assume it is `///`
-                        if !buf.is_empty() {
-                            buf.push('\n');
-                        }
-                        buf.push_str("///");
-                        buf.push_str(&line);
-                    }
+                }),
+            ..
+        }) = attr.meta
+        {
+            let mut line = s.value();
+
+            if line.contains('\n') {
+                // Must be a block comment `/** ... */`
+                if !buf.is_empty() {
+                    comments.push(buf.clone());
+                    buf.clear();
+                }
+                line.insert_str(0, "/**");
+                line.push_str("*/");
+                comments.push(line);
+            } else {
+                // Single line - assume it is `///`
+                if !buf.is_empty() {
+                    buf.push('\n');
                 }
+                buf.push_str("///");
+                buf.push_str(&line);
             }
         }
     }
@@ -189,7 +187,7 @@ pub fn doc_attributes(attrs: &[syn::Attribute]) -> syn::Result<Vec<String>> {
 pub fn collect_cfg_attr(attrs: &[syn::Attribute]) -> Vec<syn::Attribute> {
     attrs
         .iter()
-        .filter(|&a| a.path.get_ident().map_or(false, |i| *i == "cfg"))
+        .filter(|&a| a.path().is_ident("cfg"))
         .cloned()
         .collect()
 }

codegen/src/function.rs

@@ -47,8 +47,8 @@ pub enum FnSpecialAccess {
 }
 
 impl Default for FnSpecialAccess {
-    fn default() -> FnSpecialAccess {
-        FnSpecialAccess::None
+    fn default() -> Self {
+        Self::None
     }
 }
 
@@ -309,7 +309,7 @@ impl Parse for ExportedFn {
                 {
                     pass_context = true;
                 }
-                _ => {}
+                _ => (),
             }
         }
 
@@ -389,7 +389,7 @@ impl Parse for ExportedFn {
                         "Rhai functions cannot return references",
                     ))
                 }
-                _ => {}
+                _ => (),
             }
         }
         Ok(ExportedFn {
@@ -597,7 +597,7 @@ impl ExportedFn {
                     "index setter cannot return any value",
                 ))
             }
-            _ => {}
+            _ => (),
         }
 
         self.params = params;

codegen/src/register.rs

@@ -37,13 +37,14 @@ pub fn parse_register_macro(
         syn::Expr::Lit(lit_str) => quote_spanned!(items[1].span() => #lit_str),
         expr => quote! { #expr },
     };
-    let rust_mod_path = if let syn::Expr::Path(ref path) = &items[2] {
-        path.path.clone()
-    } else {
-        return Err(syn::Error::new(
-            items[2].span(),
-            "third argument must be a function name",
-        ));
+    let rust_mod_path = match &items[2] {
+        syn::Expr::Path(ref path) => path.path.clone(),
+        _ => {
+            return Err(syn::Error::new(
+                items[2].span(),
+                "third argument must be a function name",
+            ))
+        }
     };
     let module = items.remove(0);
     Ok((module, export_name, rust_mod_path))

codegen/ui_tests/export_mod_cfg.stderr

@@ -1,8 +1,8 @@
 error: expected attribute arguments in parentheses: #[rhai_fn(...)]
-  --> ui_tests/export_mod_cfg.rs:12:1
+  --> ui_tests/export_mod_cfg.rs:12:3
    |
 12 | #[rhai_fn]
-   | ^^^^^^^^^^
+   |   ^^^^^^^
 
 error[E0433]: failed to resolve: use of undeclared crate or module `test_mod`
   --> ui_tests/export_mod_cfg.rs:23:8

src/api/build_type.rs

@@ -262,10 +262,9 @@ impl<'a, T: Variant + Clone> TypeBuilder<'a, T> {
 impl<'a, T: Variant + Clone> Drop for TypeBuilder<'a, T> {
     #[inline]
     fn drop(&mut self) {
-        if let Some(name) = self.name {
-            self.engine.register_type_with_name::<T>(name);
-        } else {
-            self.engine.register_type::<T>();
-        }
+        match self.name {
+            Some(name) => self.engine.register_type_with_name::<T>(name),
+            None => self.engine.register_type::<T>(),
+        };
     }
 }

src/api/compile.rs

@@ -227,12 +227,15 @@ impl Engine {
 
         let mut interner;
         let mut guard;
-        let interned_strings = if let Some(ref interner) = self.interned_strings {
-            guard = locked_write(interner);
-            &mut *guard
-        } else {
-            interner = StringsInterner::new();
-            &mut interner
+        let interned_strings = match self.interned_strings {
+            Some(ref interner) => {
+                guard = locked_write(interner);
+                &mut *guard
+            }
+            None => {
+                interner = StringsInterner::new();
+                &mut interner
+            }
         };
 
         let state = &mut ParseState::new(scope, interned_strings, tc);
@@ -308,12 +311,15 @@ impl Engine {
 
         let mut interner;
         let mut guard;
-        let interned_strings = if let Some(ref interner) = self.interned_strings {
-            guard = locked_write(interner);
-            &mut *guard
-        } else {
-            interner = StringsInterner::new();
-            &mut interner
+        let interned_strings = match self.interned_strings {
+            Some(ref interner) => {
+                guard = locked_write(interner);
+                &mut *guard
+            }
+            None => {
+                interner = StringsInterner::new();
+                &mut interner
+            }
         };
 
         let state = &mut ParseState::new(Some(scope), interned_strings, t);

src/api/eval.rs

@@ -122,12 +122,15 @@ impl Engine {
         let ast = {
             let mut interner;
             let mut guard;
-            let interned_strings = if let Some(ref interner) = self.interned_strings {
-                guard = locked_write(interner);
-                &mut *guard
-            } else {
-                interner = StringsInterner::new();
-                &mut interner
+            let interned_strings = match self.interned_strings {
+                Some(ref interner) => {
+                    guard = locked_write(interner);
+                    &mut *guard
+                }
+                None => {
+                    interner = StringsInterner::new();
+                    &mut interner
+                }
             };
 
             let (stream, tc) = self.lex_raw(&scripts, self.token_mapper.as_deref());

src/api/files.rs

@@ -35,10 +35,11 @@ impl Engine {
 
         if contents.starts_with("#!") {
             // Remove shebang
-            if let Some(n) = contents.find('\n') {
-                contents.drain(0..n).count();
-            } else {
-                contents.clear();
+            match contents.find('\n') {
+                Some(n) => {
+                    contents.drain(0..n).count();
+                }
+                None => contents.clear(),
             }
         };
 

src/api/formatting.rs

@@ -227,12 +227,9 @@ impl Engine {
     #[must_use]
     pub(crate) fn format_type_name<'a>(&'a self, name: &'a str) -> std::borrow::Cow<'a, str> {
         if let Some(x) = name.strip_prefix("&mut ") {
-            let r = self.format_type_name(x);
-
-            return if x == r {
-                name.into()
-            } else {
-                format!("&mut {r}").into()
+            return match self.format_type_name(x) {
+                r if r == x => name.into(),
+                r => format!("&mut {r}").into(),
             };
         }
 

src/api/json.rs

@@ -118,12 +118,15 @@ impl Engine {
         let ast = {
             let mut interner;
             let mut guard;
-            let interned_strings = if let Some(ref interner) = self.interned_strings {
-                guard = locked_write(interner);
-                &mut *guard
-            } else {
-                interner = StringsInterner::new();
-                &mut interner
+            let interned_strings = match self.interned_strings {
+                Some(ref interner) => {
+                    guard = locked_write(interner);
+                    &mut *guard
+                }
+                None => {
+                    interner = StringsInterner::new();
+                    &mut interner
+                }
             };
 
             let state = &mut ParseState::new(None, interned_strings, tokenizer_control);
@@ -174,12 +177,10 @@ pub fn format_map_as_json(map: &Map) -> String {
         write!(result, "{key:?}").unwrap();
         result.push(':');
 
-        if let Some(val) = value.read_lock::<Map>() {
-            result.push_str(&format_map_as_json(&val));
-        } else if value.is_unit() {
-            result.push_str("null");
-        } else {
-            write!(result, "{value:?}").unwrap();
+        match value.read_lock::<Map>() {
+            Some(val) => result.push_str(&format_map_as_json(&val)),
+            None if value.is_unit() => result.push_str("null"),
+            None => write!(result, "{value:?}").unwrap(),
         }
     }
 

src/api/optimize.rs

@@ -63,10 +63,11 @@ impl Engine {
         );
 
         #[cfg(feature = "metadata")]
-        if let Some(doc) = ast.doc_mut() {
-            _new_ast.set_doc(std::mem::take(doc));
-        } else {
-            _new_ast.clear_doc();
+        match ast.doc_mut() {
+            Some(doc) => _new_ast.set_doc(std::mem::take(doc)),
+            None => {
+                _new_ast.clear_doc();
+            }
         }
 
         _new_ast

src/api/run.rs

@@ -63,12 +63,15 @@ impl Engine {
 
             let mut interner;
             let mut guard;
-            let interned_strings = if let Some(ref interner) = self.interned_strings {
-                guard = locked_write(interner);
-                &mut *guard
-            } else {
-                interner = StringsInterner::new();
-                &mut interner
+            let interned_strings = match self.interned_strings {
+                Some(ref interner) => {
+                    guard = locked_write(interner);
+                    &mut *guard
+                }
+                None => {
+                    interner = StringsInterner::new();
+                    &mut interner
+                }
             };
 
             let state = &mut ParseState::new(Some(scope), interned_strings, tc);