Refactor JSError:

- Replace JSError::ParseError with parse_error_here! macro
- Replace JSError::EvaluationError with eval_error_here! macro

- Added eval_error_here import in affected files

Author: ssrlive

Cargo.toml

@@ -13,6 +13,7 @@ categories = ["development-tools", "parsing"]
 
 [dependencies]
 chrono = { version = "0.4.42", features = ["serde"] }
+function_name = "0.3"
 libc = "0.2.178"
 log = "0.4.29"
 num-bigint = "0.4.6"

examples/js.rs

@@ -43,7 +43,7 @@ fn main() {
         match evaluate_script(script) {
             Ok(result) => print_eval_result(&result),
             Err(err) => {
-                eprintln!("Evaluation failed: {:?}", err);
+                eprintln!("Evaluation failed: {err}");
                 process::exit(1);
             }
         }

src/core.rs

@@ -2,6 +2,7 @@
 #![allow(non_camel_case_types)]
 
 use crate::error::JSError;
+use crate::eval_error_here;
 use crate::js_promise::{PromiseState, run_event_loop};
 use crate::unicode::{utf8_to_utf16, utf16_to_utf8};
 use std::cell::RefCell;
@@ -102,9 +103,7 @@ pub fn evaluate_script<T: AsRef<str>>(script: T) -> Result<Value, JSError> {
                     match &promise_borrow.state {
                         PromiseState::Fulfilled(val) => return Ok(val.clone()),
                         PromiseState::Rejected(reason) => {
-                            return Err(JSError::EvaluationError {
-                                message: format!("Promise rejected: {}", value_to_string(reason)),
-                            });
+                            return Err(eval_error_here!(format!("Promise rejected: {}", value_to_string(reason))));
                         }
                         PromiseState::Pending => {
                             // Continue running the event loop

src/core/eval.rs

@@ -3,11 +3,16 @@ pub enum JSError {
     #[error("Tokenization failed")]
     TokenizationError,
 
-    #[error("Parsing failed")]
-    ParseError,
+    #[error("Parsing failed at {method} {file}:{line}")]
+    ParseError { file: String, line: usize, method: String },
 
-    #[error("Evaluation failed: {message}")]
-    EvaluationError { message: String },
+    #[error("Evaluation failed at {method} {file}:{line}: {message}")]
+    EvaluationError {
+        message: String,
+        file: String,
+        line: usize,
+        method: String,
+    },
 
     #[error("Infinite loop detected (executed {iterations} iterations)")]
     InfiniteLoopError { iterations: usize },
@@ -39,3 +44,46 @@ impl From<JSError> for std::io::Error {
         }
     }
 }
+
+// Macro that constructs a ParseError using the compile-time caller
+// location. Using a macro (rather than a function) ensures `file!()` and
+// `line!()` expand to the site where the macro is invoked.
+#[macro_export]
+macro_rules! parse_error_here {
+    () => {
+        $crate::JSError::ParseError {
+            file: file!().to_string(),
+            line: line!() as usize,
+            method: $crate::function_name!().to_string(),
+        }
+    };
+}
+
+// Macro that constructs an EvaluationError using the compile-time caller
+// location and the provided message. Using a macro (rather than a
+// function) ensures `file!()` and `line!()` expand to the site where the
+// macro is invoked.
+#[macro_export]
+macro_rules! eval_error_here {
+    ($msg:expr) => {
+        $crate::JSError::EvaluationError {
+            message: $msg.to_string(),
+            file: file!().to_string(),
+            line: line!() as usize,
+            method: $crate::function_name!().to_string(),
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! function_name {
+    () => {{
+        fn f() {}
+        fn type_name_of<T>(_: T) -> &'static str {
+            std::any::type_name::<T>()
+        }
+        let name = type_name_of(f);
+        // remove the trailing "::f"
+        &name[..name.len() - 3]
+    }};
+}