feat: adding proper error backtrace and display

Author: SilentVoid13

.gitignore

@@ -1,2 +1,3 @@
 /target
 /Cargo.lock
+/benchmark

src/error.rs

@@ -5,14 +5,14 @@ pub type Result<T> = std::result::Result<T, RenderError>;
 
 #[derive(Error, Debug, PartialEq)]
 pub enum RenderError {
-    #[error("Syntax error")]
+    #[error("Syntax error inside command")]
     SyntaxError,
-    #[error("Function error")]
+    #[error("Template function call error")]
     FunctionError,
-    #[error("Missing command tag")]
-    MissingCommandTag,
-    #[error("Missing closing tag")]
-    MissingClosingTag,
+    #[error("Missing command type at `{0}`")]
+    MissingCommandType(String),
+    #[error("Missing closing command tag at `{0}`")]
+    MissingClosingTag(String),
 }
 
 impl Into<JsValue> for RenderError {

src/lib.rs

@@ -7,11 +7,11 @@ use std::collections::HashMap;
 use std::fmt::Write;
 
 use serde::{Deserialize, Serialize};
+use utils::count_newlines;
 use wasm_bindgen::prelude::*;
 
 use crate::error::RenderError;
 use crate::error::Result;
-use crate::utils::log;
 
 #[derive(Debug, PartialEq)]
 pub enum CommandType {
@@ -39,6 +39,11 @@ pub enum Token<'a> {
     Command(Command<'a>),
 }
 
+pub struct ParsingData {
+    line: usize,
+    ch: usize,
+}
+
 #[wasm_bindgen]
 #[derive(Serialize, Deserialize, Debug)]
 pub struct ParserConfig {
@@ -115,35 +120,56 @@ impl<'a> Parser<'a> {
         Parser { content, config }
     }
 
-    fn parse_command_tag(&self, i: &'a str) -> Result<(CommandType, &'a str)> {
+    fn generate_backtrace(&self, d: &ParsingData) -> String {
+        let line = self.content.lines().skip(d.line as usize).next().unwrap();
+        let line_ch: usize = self
+            .content
+            .split('\n')
+            .take(d.line as usize)
+            .map(|l| l.len()+1)
+            .sum();
+        let ch = d.ch - line_ch;
+        let mut spaces: String = (0..ch-1).map(|_| ' ').collect();
+        spaces += "^";
+        let s = format!("line {} col {}:\n\n{}\n{}", d.line + 1, ch, line, spaces);
+        s
+    }
+
+    fn parse_command_tag(&self, i: &'a str, d: &mut ParsingData) -> Result<(CommandType, &'a str)> {
         let c = i.chars().next();
         let c = match c {
             Some(c) => c,
-            None => return Err(RenderError::MissingCommandTag),
+            None => return Err(RenderError::MissingCommandType(self.generate_backtrace(d))),
         };
 
         // TODO: improve this
         let mut input = i;
         let cmd_type = if c == self.config.execution {
             input = &i[1..];
+            d.ch += 1;
             CommandType::Execution
         } else if c == self.config.interpolate {
             input = &i[1..];
+            d.ch += 1;
             CommandType::Interpolate
         } else {
             if self.config.interpolate == '\0' {
                 CommandType::Interpolate
             } else if self.config.execution == '\0' {
                 CommandType::Execution
             } else {
-                return Err(RenderError::MissingCommandTag);
+                return Err(RenderError::MissingCommandType(self.generate_backtrace(d)));
             }
         };
 
         Ok((cmd_type, input))
     }
 
-    fn parse_whitespace(&self, i: &'a str) -> Result<(Option<Whitespace>, &'a str)> {
+    fn parse_whitespace(
+        &self,
+        i: &'a str,
+        d: &mut ParsingData,
+    ) -> Result<(Option<Whitespace>, &'a str)> {
         let c = i.chars().next();
         let whitespace = match c {
             Some(c) => {
@@ -160,15 +186,17 @@ impl<'a> Parser<'a> {
         let mut input = i;
         if whitespace.is_some() {
             input = &i[1..];
+            d.ch += 1;
         }
         Ok((whitespace, input))
     }
 
-    fn parse_closing_tag(&self, i: &'a str) -> Result<(&'a str, &'a str)> {
+    fn parse_closing_tag(&self, i: &'a str, d: &mut ParsingData) -> Result<(&'a str, &'a str)> {
         let (content, i) = match i.split_once(&self.config.closing_tag) {
             Some(x) => x,
-            None => return Err(RenderError::MissingClosingTag),
+            None => return Err(RenderError::MissingClosingTag(self.generate_backtrace(d))),
         };
+        d.ch += self.config.closing_tag.len();
         Ok((content, i))
     }
 
@@ -186,7 +214,7 @@ impl<'a> Parser<'a> {
         res.iter().collect()
     }
 
-    pub fn trim_whitespace<'b>(
+    fn trim_whitespace<'b>(
         &self,
         i: &'b str,
         whitespace: Option<&Whitespace>,
@@ -210,7 +238,7 @@ impl<'a> Parser<'a> {
                             }
                         }
                         x
-                    },
+                    }
                     Some('\r') => {
                         let mut x = 1;
                         if left {
@@ -245,25 +273,34 @@ impl<'a> Parser<'a> {
     pub fn parse_tokens(&self) -> Result<Vec<Token>> {
         let mut tokens = vec![];
         let mut input = self.content;
+        let mut parsing_data = ParsingData { ch: 0, line: 0 };
 
         while let Some((text, i)) = input.split_once(&self.config.opening_tag) {
+            parsing_data.ch += self.config.opening_tag.len();
+
             if !text.is_empty() {
                 tokens.push(Token::Text(text));
+                parsing_data.ch += text.len();
+                parsing_data.line += count_newlines(text);
             }
 
-            let (cmd_type, i) = self.parse_command_tag(i)?;
-            let (opening_whitespace, i) = self.parse_whitespace(i)?;
-            let (part1, i) = self.parse_closing_tag(i)?;
+            let (opening_whitespace, i) = self.parse_whitespace(i, &mut parsing_data)?;
+            let (cmd_type, i) = self.parse_command_tag(i, &mut parsing_data)?;
+            let (part1, i) = self.parse_closing_tag(i, &mut parsing_data)?;
 
             // TODO: improve that
             let content_whitespace = &part1[part1.len() - 1..];
-            let (closing_whitespace, _) = self.parse_whitespace(content_whitespace)?;
+            let (closing_whitespace, _) =
+                self.parse_whitespace(content_whitespace, &mut parsing_data)?;
             let content = if closing_whitespace.is_none() {
                 part1
             } else {
                 &part1[..part1.len() - 1]
             };
 
+            parsing_data.ch += content.len();
+            parsing_data.line += count_newlines(content);
+
             let command = Command {
                 r#type: cmd_type,
                 opening_whitespace,
@@ -276,6 +313,8 @@ impl<'a> Parser<'a> {
         }
         if !input.is_empty() {
             tokens.push(Token::Text(input));
+            parsing_data.ch += input.len();
+            parsing_data.line += count_newlines(input);
         }
 
         Ok(tokens)
@@ -362,13 +401,11 @@ impl Renderer {
         let parser = Parser::new(content, &self.config);
         let tokens = parser.parse_tokens()?;
         let fn_body = parser.generate_js(tokens);
-        let async_fn = match self
-            .async_constructor
-            .call2(
-                &JsValue::NULL,
-                &JsValue::from("tp"),
-                &JsValue::from(&fn_body).into(),
-            ) {
+        let async_fn = match self.async_constructor.call2(
+            &JsValue::NULL,
+            &JsValue::from("tp"),
+            &JsValue::from(&fn_body).into(),
+        ) {
             Ok(f) => f,
             Err(_) => return Err(RenderError::SyntaxError),
         };

src/utils.rs

@@ -1,3 +1,6 @@
+pub fn count_newlines(s: &str) -> usize {
+    s.as_bytes().iter().filter(|&c| *c == b'\n').count()
+}
 
 macro_rules! log {
     ( $( $t:tt )* ) => {

tests/error.rs

@@ -9,24 +9,30 @@ use rusty_engine::{error::RenderError, Parser, ParserConfig, Renderer};
 #[wasm_bindgen_test]
 pub fn test_missing_closing_tag() {
     let config = ParserConfig::new("<%".into(), "%>".into(), '\0', '*', '-', '_', "tR".into());
-    let content = r#"test
-<%_ test -%>
-test
-<% test"#;
+    let content = "test\r\n<%_ test1 -%>\r\ntest\r\ntesttest <% test2";
+    let err = r#"line 4 col 11:
+
+testtest <% test2
+          ^"#;
 
     let parser = Parser::new(content, &config);
     let tokens = parser.parse_tokens();
-    assert_eq!(tokens, Err(RenderError::MissingClosingTag));
+    assert_eq!(tokens, Err(RenderError::MissingClosingTag(err.into())));
 }
 
 #[wasm_bindgen_test]
 pub fn test_missing_command_tag() {
     let config = ParserConfig::new("<%".into(), "%>".into(), '~', '*', '-', '_', "tR".into());
-    let content = r#"test <% test %> test"#;
+    let content = r#"test 
+test <% test %> test"#;
+    let err = r#"line 2 col 7:
+
+test <% test %> test
+      ^"#;
 
     let parser = Parser::new(content, &config);
     let tokens = parser.parse_tokens();
-    assert_eq!(tokens, Err(RenderError::MissingCommandTag));
+    assert_eq!(tokens, Err(RenderError::MissingCommandType(err.into())));
 }
 
 #[wasm_bindgen_test]

tests/web.rs

@@ -20,7 +20,7 @@ pub fn test_parse_tokens() {
 test<%_ test %>test
 <%- test _%>
 test
-<%*_ test -%> test <% test %>
+<%_* test -%> test <% test %>
 test"#;
 
     let parser = Parser::new(content, &config);
@@ -73,7 +73,7 @@ pub fn test_generate_js() {
         '_',
         "tR".into(),
     );
-    let content = "<%- test -%>\ntest\n\n<%*_ test %>'test'<% test %>";
+    let content = "<%- test -%>\ntest\n\n<%_* test %>'test'<% test %>";
     let parser = Parser::new(content, &config);
     let tokens = parser.parse_tokens().unwrap();
     let js_func = parser.generate_js(tokens);
@@ -108,7 +108,7 @@ pub fn test_whitespace_control() {
         '_',
         "tR".into(),
     );
-    let content = "\ntest\n\n<%_ test -%>\r\n\ntest\n\r<%*- test _%>\rtest\r\n<%*- test -%> test <% test %>\ntest";
+    let content = "\ntest\n\n<%_ test -%>\r\n\ntest\n\r<%-* test _%>\rtest\r\n<%-* test -%> test <% test %>\ntest";
 
     let parser = Parser::new(content, &config);
     let tokens = parser.parse_tokens().unwrap();