Remove dynamic allocation with numbers

Author: udoprog

crates/rune-modules/src/rand/macros.rs

@@ -256,13 +256,25 @@ macro_rules! random_ranges {
                                 let range = value.borrow_ref::<RangeInclusive>()?;
                                 let start = $as(&range.start)?;
                                 let end = $as(&range.end)?;
-                                rand::Rng::random_range(&mut this.inner, start..=end)
+                                let range = start..=end;
+
+                                if range.is_empty() {
+                                    return Err(VmError::panic("cannot sample empty range"));
+                                }
+
+                                rand::Rng::random_range(&mut this.inner, range)
                             }
                             Range::HASH => {
                                 let range = value.borrow_ref::<Range>()?;
                                 let start = $as(&range.start)?;
                                 let end = $as(&range.end)?;
-                                rand::Rng::random_range(&mut this.inner, start..end)
+                                let range = start..end;
+
+                                if range.is_empty() {
+                                    return Err(VmError::panic("cannot sample empty range"));
+                                }
+
+                                rand::Rng::random_range(&mut this.inner, range)
                             }
                             _ => {
                                 return Err(VmError::panic("unsupported range"));

crates/rune/Cargo.toml

@@ -29,7 +29,7 @@ byte-code = ["alloc", "musli", "dep:musli", "musli/storage", "musli/std", "rune-
 capture-io = ["alloc", "parking_lot"]
 disable-io = ["alloc"]
 fmt = ["alloc", "anyhow"]
-std = ["alloc", "num/std", "serde/std", "rune-core/std", "rune-alloc/std", "musli?/std", "once_cell/std", "anyhow?/std", "syntree/std", "tokio?/io-std"]
+std = ["alloc", "serde/std", "rune-core/std", "rune-alloc/std", "musli?/std", "once_cell/std", "anyhow?/std", "syntree/std", "tokio?/io-std"]
 alloc = ["rune-alloc/alloc", "rune-core/alloc", "once_cell/alloc", "serde?/alloc"]
 musli = ["dep:musli-core", "rune-core/musli", "rune-alloc/musli"]
 serde = ["dep:serde", "rune-alloc/serde", "relative-path?/serde"]
@@ -44,7 +44,6 @@ syntree = { version = "0.18.0", default-features = false, features = ["alloc"] }
 futures-core = { version = "0.3.28", default-features = false }
 futures-util = { version = "0.3.28", default-features = false, features = ["alloc"] }
 itoa = "1.0.6"
-num = { version = "0.4.0", default-features = false, features = ["alloc"] }
 pin-project = "1.1.0"
 ryu = "1.0.13"
 serde = { version = "1.0.163", default-features = false, optional = true, features = ["derive", "rc"] }

crates/rune/src/ast/expr_object.rs

@@ -114,7 +114,7 @@ impl Parse for ObjectKey {
 impl<'a> Resolve<'a> for ObjectKey {
     type Output = Cow<'a, str>;
 
-    fn resolve(&self, cx: ResolveContext<'a>) -> Result<Self::Output> {
+    fn resolve(&self, cx: ResolveContext<'a, '_>) -> Result<Self::Output> {
         Ok(match self {
             Self::LitStr(lit_str) => lit_str.resolve(cx)?,
             Self::Path(path) => {

crates/rune/src/ast/ident.rs

@@ -76,7 +76,7 @@ impl Peek for Ident {
 impl<'a> Resolve<'a> for Ident {
     type Output = &'a str;
 
-    fn resolve(&self, cx: ResolveContext<'a>) -> Result<&'a str> {
+    fn resolve(&self, cx: ResolveContext<'a, '_>) -> Result<&'a str> {
         let span = self.span;
 
         match self.source {

crates/rune/src/ast/label.rs

@@ -72,7 +72,7 @@ impl Peek for Label {
 impl<'a> Resolve<'a> for Label {
     type Output = &'a str;
 
-    fn resolve(&self, cx: ResolveContext<'a>) -> Result<&'a str> {
+    fn resolve(&self, cx: ResolveContext<'a, '_>) -> Result<&'a str> {
         let span = self.span;
 
         match self.source {

crates/rune/src/ast/lit_byte.rs

@@ -54,7 +54,7 @@ impl Parse for LitByte {
 impl<'a> Resolve<'a> for LitByte {
     type Output = u8;
 
-    fn resolve(&self, cx: ResolveContext<'a>) -> Result<u8> {
+    fn resolve(&self, cx: ResolveContext<'a, '_>) -> Result<u8> {
         let source_id = match self.source {
             ast::CopySource::Inline(b) => return Ok(b),
             ast::CopySource::Text(source_id) => source_id,

crates/rune/src/ast/lit_byte_str.rs

@@ -90,7 +90,7 @@ impl Parse for LitByteStr {
 impl<'a> Resolve<'a> for LitByteStr {
     type Output = Cow<'a, [u8]>;
 
-    fn resolve(&self, cx: ResolveContext<'a>) -> Result<Cow<'a, [u8]>> {
+    fn resolve(&self, cx: ResolveContext<'a, '_>) -> Result<Cow<'a, [u8]>> {
         let span = self.span;
 
         let text = match self.source {

crates/rune/src/ast/lit_char.rs

@@ -54,7 +54,7 @@ impl Parse for LitChar {
 impl<'a> Resolve<'a> for LitChar {
     type Output = char;
 
-    fn resolve(&self, cx: ResolveContext<'a>) -> Result<char> {
+    fn resolve(&self, cx: ResolveContext<'a, '_>) -> Result<char> {
         let source_id = match self.source {
             ast::CopySource::Inline(c) => return Ok(c),
             ast::CopySource::Text(source_id) => source_id,

crates/rune/src/ast/lit_number.rs

@@ -1,7 +1,7 @@
 use crate::ast::prelude::*;
+use crate::compile::{num, WithSpan};
 
 use ast::token::NumberSize;
-use num::Num;
 
 #[test]
 #[cfg(not(miri))]
@@ -59,11 +59,7 @@ impl Parse for LitNumber {
 impl<'a> Resolve<'a> for LitNumber {
     type Output = ast::Number;
 
-    fn resolve(&self, cx: ResolveContext<'a>) -> Result<ast::Number> {
-        fn err_span<E>(span: Span) -> impl Fn(E) -> compile::Error {
-            move |_| compile::Error::new(span, ErrorKind::BadNumberLiteral)
-        }
-
+    fn resolve(&self, cx: ResolveContext<'a, '_>) -> Result<ast::Number> {
         let span = self.span;
 
         let text = match self.source {
@@ -116,28 +112,27 @@ impl<'a> Resolve<'a> for LitNumber {
             (suffix, text.is_fractional),
             (Some(ast::NumberSuffix::Float(..)), _) | (None, true)
         ) {
-            let number: f64 = string
-                .trim_matches(|c: char| c == '_')
-                .parse()
-                .map_err(err_span(span))?;
+            let number: f64 = num::from_float(cx.scratch, string).with_span(span)?;
 
             return Ok(ast::Number {
                 value: ast::NumberValue::Float(number),
                 suffix,
             });
         }
 
-        let radix = match text.base {
-            ast::NumberBase::Binary => 2,
-            ast::NumberBase::Octal => 8,
-            ast::NumberBase::Hex => 16,
-            ast::NumberBase::Decimal => 10,
+        let parser = match text.base {
+            ast::NumberBase::Binary => num::from_ascii_binary,
+            ast::NumberBase::Octal => num::from_ascii_octal,
+            ast::NumberBase::Hex => num::from_ascii_hex,
+            ast::NumberBase::Decimal => num::from_ascii_decimal,
         };
 
-        let number = num::BigInt::from_str_radix(string, radix).map_err(err_span(span))?;
+        let number = parser(string.as_bytes())
+            .ok_or_else(|| ErrorKind::BadNumberLiteral)
+            .with_span(span)?;
 
         Ok(ast::Number {
-            value: ast::NumberValue::Integer(number),
+            value: ast::NumberValue::Integer(number as i128),
             suffix,
         })
     }

crates/rune/src/ast/lit_str.rs

@@ -27,20 +27,20 @@ impl LitStr {
     /// Resolve a template string.
     pub(crate) fn resolve_template_string<'a>(
         &self,
-        cx: ResolveContext<'a>,
+        cx: ResolveContext<'a, '_>,
     ) -> Result<Cow<'a, str>> {
         self.resolve_inner(cx, ast::unescape::WithTemplate(true))
     }
 
     /// Resolve as a regular string.
-    pub(crate) fn resolve_string<'a>(&self, cx: ResolveContext<'a>) -> Result<Cow<'a, str>> {
+    pub(crate) fn resolve_string<'a>(&self, cx: ResolveContext<'a, '_>) -> Result<Cow<'a, str>> {
         self.resolve_inner(cx, ast::unescape::WithTemplate(false))
     }
 
     /// Resolve the given string with the specified configuration.
     fn resolve_inner<'a>(
         &self,
-        cx: ResolveContext<'a>,
+        cx: ResolveContext<'a, '_>,
         with_template: ast::unescape::WithTemplate,
     ) -> Result<Cow<'a, str>> {
         let span = self.span;
@@ -150,7 +150,7 @@ impl Parse for LitStr {
 impl<'a> Resolve<'a> for LitStr {
     type Output = Cow<'a, str>;
 
-    fn resolve(&self, cx: ResolveContext<'a>) -> Result<Cow<'a, str>> {
+    fn resolve(&self, cx: ResolveContext<'a, '_>) -> Result<Cow<'a, str>> {
         self.resolve_string(cx)
     }
 }