chore: Remove unused dependencies

Cargo.toml

@@ -60,30 +60,26 @@ required-features = ["piston"]
 name = "ion"
 path = "src/main.rs"
 
-[build-dependencies]
-version_check = "0.9"
-
 [dependencies]
 calculate = { git = "https://gitlab.redox-os.org/redox-os/calc" }
 err-derive = "0.1"
 glob = "0.3"
-itoa = "0.4"
 liner = { git = "https://gitlab.redox-os.org/redox-os/liner" }
 rand = "0.7"
-regex = "1.1"
+regex = "1.2"
 small = { git = "https://gitlab.redox-os.org/redox-os/small", features = ["std"] }
 smallvec = "0.6"
-unicode-segmentation = "1.2"
+unicode-segmentation = "1.3"
 ion-ranges = { version = "0.1", path = "members/ranges" }
 scopes = { version = "0.1", path = "members/scopes-rs" }
 types-rs = { version = "0.1", path = "members/types-rs" }
 builtins-proc = { version = "0.1", path = "members/builtins-proc" }
-hashbrown = "0.5"
+hashbrown = "0.6"
 itertools = "0.8"
-lexical = "2.0"
+lexical = "3.0"
 object-pool = "0.3.1"
 auto_enums = "0.5.5"
-structopt = "^0.2"
+structopt = "0.2"
 atty = "0.2"
 permutate = "0.3"
 xdg = "2.1"

members/builtins-proc/Cargo.toml

@@ -5,9 +5,9 @@ authors = ["Xavier L'Heureux <xavier.lheureux@icloud.com>"]
 edition = "2018"
 
 [dependencies]
-quote = "0.6"
-syn = { version = "0.15", features = ["full"] }
-darling = "0.9"
+quote = "1.0"
+syn = { version = "1.0", features = ["full"] }
+darling = "0.10"
 
 [dev-dependencies]
 ion-shell = { path = "../.." }

members/builtins-proc/src/lib.rs

@@ -22,15 +22,15 @@ struct MacroArgs {
 pub fn builtin(attr: TokenStream, item: TokenStream) -> TokenStream {
     let input = syn::parse_macro_input!(item as syn::ItemFn);
     let attrs = syn::parse_macro_input!(attr as syn::AttributeArgs);
-    let syn::ItemFn { vis, decl, block, ident, .. } = &input;
-    let syn::FnDecl { ref fn_token, ref inputs, ref output, .. } = **decl;
+    let syn::ItemFn { vis, sig, block, .. } = &input;
+    let syn::Signature { ident, fn_token, inputs, output, .. } = sig;
 
     let args = match MacroArgs::from_list(&attrs) {
         Ok(v) => v,
         Err(e) => return e.write_errors().into(),
     };
 
-    let name = syn::Ident::new(&format!("builtin_{}", &ident), input.ident.span());
+    let name = quote::format_ident!("builtin_{}", &ident, span = ident.span());
 
     let help = args.help.trim();
     let names = args.names.unwrap_or_else(|| ident.to_string());

members/scopes-rs/Cargo.toml

@@ -11,4 +11,4 @@ keywords = ["scopes", "variables"]
 categories = ["data-structures", "memory-management"]
 
 [dependencies]
-hashbrown = "0.5"
+hashbrown = "0.6"

members/types-rs/Cargo.toml

@@ -11,8 +11,7 @@ readme = "README.md"
 categories = ["parsing"]
 
 [dependencies]
-lexical = "2.0"
-hashbrown = "0.5"
+lexical = "3.0"
+hashbrown = "0.6"
 small = { git = "https://gitlab.redox-os.org/redox-os/small", features = ["std"] }
-smallvec = "0.6"
 itertools = "0.8"

members/types-rs/src/math.rs

@@ -31,14 +31,14 @@ macro_rules! math {
             fn $fn(self, rhs: Self) -> Self::Output {
                 if let Value::Str(rhs) = rhs {
                     if $allfloat {
-                        lexical::try_parse::<f64, _>(rhs)
+                        lexical::parse::<f64, _>(rhs)
                             .map_err(OpError::ParseError)
                             .and_then(|rhs| self.$fn(rhs))
                     } else {
-                        if let Ok(rhs) = lexical::try_parse::<i128, _>(rhs) {
+                        if let Ok(rhs) = lexical::parse::<i128, _>(rhs) {
                             self.$fn(rhs)
                         } else {
-                            lexical::try_parse::<f64, _>(rhs)
+                            lexical::parse::<f64, _>(rhs)
                                 .map_err(OpError::ParseError)
                                 .and_then(|rhs| self.$fn(rhs))
                         }
@@ -61,16 +61,16 @@ macro_rules! math {
             fn $fn(self, rhs: i128) -> Self::Output {
                 match self {
                     Value::Str(lhs) => if $allfloat {
-                        lexical::try_parse::<f64, _>(lhs)
+                        lexical::parse::<f64, _>(lhs)
                             .map_err(OpError::ParseError)
                             .map(|lhs| lexical::to_string($op_f_f(lhs, rhs as f64)))
                     } else {
-                        if let Ok(lhs) = lexical::try_parse::<i128, _>(lhs) {
+                        if let Ok(lhs) = lexical::parse::<i128, _>(lhs) {
                             $op_i_i(lhs, rhs)
                                 .ok_or(OpError::CalculationError)
                                 .map(lexical::to_string)
                         } else {
-                            lexical::try_parse::<f64, _>(lhs)
+                            lexical::parse::<f64, _>(lhs)
                                 .map_err(OpError::ParseError)
                                 .map(|lhs| lexical::to_string($op_f_f(lhs, rhs as f64)))
                         }
@@ -89,7 +89,7 @@ macro_rules! math {
 
             fn $fn(self, rhs: f64) -> Self::Output {
                 match self {
-                    Value::Str(lhs) => lexical::try_parse::<f64, _>(lhs)
+                    Value::Str(lhs) => lexical::parse::<f64, _>(lhs)
                         .map_err(OpError::ParseError)
                         .map(|lhs| lexical::to_string($op_f_f(lhs, rhs)))
                         .map(Value::from),