feat(interpreter): pretty error msgs on div/mod by zero

Author: Alonely0

interpreter/src/lib.rs

@@ -6,6 +6,8 @@
 pub(crate) mod ir;
 mod vm;
 
+use std::borrow::Cow;
+
 use ariadne::{Color, Label, ReportBuilder};
 pub use ir::{
     Instruction,
@@ -24,12 +26,15 @@ pub enum InterpreterError {
     RecursionDepth(AriadneSpan),
     #[error("Indirect call to an undefined function!")]
     UnknownIndFunction(AriadneSpan, String),
+    #[error("Attempted to divide `{}` by zero here!", quacks_like_a_float(.1))]
+    DivByZeroAttempted(AriadneSpan, String),
 }
 
 impl InterpreterError {
     pub fn emit_diagnostic(&self, store: &mut DiagnosticStore) {
         match self {
-            Self::UnknownIndFunction(span, _)
+            Self::DivByZeroAttempted(span, _)
+            | Self::UnknownIndFunction(span, _)
             | Self::RecursionDepth(span)
             | Self::ArityMismatch(span, _, _)
             | Self::UnknownFunction(span) => self.add_diagnostic_cached(store, span.clone()),
@@ -43,7 +48,8 @@ impl Diagnostic for InterpreterError {
     }
     fn span(&self) -> Option<Span> {
         match self {
-            Self::UnknownIndFunction((_, span), _)
+            Self::DivByZeroAttempted((_, span), _)
+            | Self::UnknownIndFunction((_, span), _)
             | Self::RecursionDepth((_, span))
             | Self::ArityMismatch((_, span), _, _)
             | Self::UnknownFunction((_, span)) => Some(span.clone()),
@@ -75,10 +81,26 @@ impl Diagnostic for InterpreterError {
             Self::UnknownIndFunction(_, name) => {
                 &format!("This code tried to call the unknown function `{name}` indirectly.")
             }
+            Self::DivByZeroAttempted(_, _) => {
+                "Division and modular arithmetic by zero is always fatal in AWK. To avoid this, \
+                you can use an\nif statement or a ternary expression. You may optionally introduce \
+                IEEE 754 not-a-number values:\n                          \
+                `a / b` --> `(+b != 0) ? (a / b) : +\"+nan\"`.\nNote the importance of the `+` \
+                operator, which forces values into numbers. Otherwise, some\nvalues of `b`, like \
+                an empty string, would still trigger this error. It also parses the \"+nan\"."
+            }
         };
         report.set_help(note);
     }
     fn is_unrecoverable(&self) -> bool {
         true
     }
 }
+
+fn quacks_like_a_float(val: &str) -> Cow<'_, str> {
+    if val.parse::<f64>().is_ok() {
+        val.into()
+    } else {
+        format!("{val:?}").into()
+    }
+}

interpreter/src/vm.rs

@@ -494,15 +494,29 @@ impl<'a> Interpreter<'a> {
                     self.write_reg(dest, val);
                 }
                 Instruction::Divide { dest, lhs, rhs, tyl, tyr } => {
-                    let val = Arg::get_val2(lhs, tyl, rhs, tyr, self, |lhs, rhs| lhs / rhs);
+                    let Some(val) = Arg::get_val2(lhs, tyl, rhs, tyr, self, |lhs, rhs| lhs / rhs)
+                    else {
+                        let uninit = &mut MaybeUninit::uninit();
+                        return Err(InterpreterError::DivByZeroAttempted(
+                            self.get_span(metadata),
+                            lhs.get_val(tyl, self, uninit).to_string(),
+                        ));
+                    };
                     self.write_reg(dest, val);
                 }
                 Instruction::Raise { dest, lhs, rhs, tyl, tyr } => {
                     let val = Arg::get_val2(lhs, tyl, rhs, tyr, self, |lhs, rhs| lhs ^ rhs);
                     self.write_reg(dest, val);
                 }
                 Instruction::Modulo { dest, lhs, rhs, tyl, tyr } => {
-                    let val = Arg::get_val2(lhs, tyl, rhs, tyr, self, |lhs, rhs| lhs % rhs);
+                    let Some(val) = Arg::get_val2(lhs, tyl, rhs, tyr, self, |lhs, rhs| lhs % rhs)
+                    else {
+                        let uninit = &mut MaybeUninit::uninit();
+                        return Err(InterpreterError::DivByZeroAttempted(
+                            self.get_span(metadata),
+                            lhs.get_val(tyl, self, uninit).to_string(),
+                        ));
+                    };
                     self.write_reg(dest, val);
                 }
                 Instruction::Concat { dest, lhs, rhs, tyl, tyr } => {

interpreter/src/vm/types.rs

@@ -8,6 +8,7 @@ use std::{
     cell::RefCell,
     fmt::Display,
     hash::Hash,
+    hint::cold_path,
     io::Write,
     mem::discriminant,
     ops::{Add, BitXor, Div, Mul, Rem, Sub},
@@ -17,6 +18,14 @@ use std::{
 use ahash::RandomState;
 use hashbrown::HashMap;
 
+#[inline(always)]
+fn likely(b: bool) -> bool {
+    if !b {
+        cold_path();
+    }
+    b
+}
+
 /// Shared array storage. AWK arrays are reference-counted (assignment of array
 /// names is not a deep copy); `Rc`/`RefCell` is enough while the VM is single-threaded.
 pub type ArrayMap<'a> = HashMap<String, Value<'a>, RandomState>;
@@ -155,13 +164,11 @@ impl<'a> Mul for &'_ Value<'a> {
 }
 
 impl<'a> Div for &'_ Value<'a> {
-    type Output = Value<'a>;
+    type Output = Option<Value<'a>>;
 
     fn div(self, rhs: Self) -> Self::Output {
         let rhs = rhs.to_num();
-        // TODO: panic "nicely" on div by zero.
-        assert!(rhs != 0., "Division by zero attempted in '/'!");
-        Value::Float(self.to_num() / rhs)
+        likely(rhs != 0.).then(|| Value::Float(self.to_num() / rhs))
     }
 }
 
@@ -174,13 +181,11 @@ impl<'a> BitXor for &'_ Value<'a> {
 }
 
 impl<'a> Rem for &'_ Value<'a> {
-    type Output = Value<'a>;
+    type Output = Option<Value<'a>>;
 
     fn rem(self, rhs: Self) -> Self::Output {
-        let (lhs, rhs) = (self.to_num(), rhs.to_num());
-        // TODO: panic "nicely" on div by zero.
-        assert!(lhs != 0. || rhs != 0., "Division by zero attempted in '%'!");
-        Value::Float(lhs % rhs)
+        let rhs = rhs.to_num();
+        likely(rhs != 0.).then(|| Value::Float(self.to_num() % rhs))
     }
 }