add ErrorNode

Author: joshuadavidthomas

crates/djls-templates/src/lib.rs

@@ -58,6 +58,7 @@ use djls_source::File;
 use djls_source::FileKind;
 pub use error::TemplateError;
 pub use lexer::Lexer;
+pub use nodelist::ErrorNode;
 pub use nodelist::NodeList;
 pub use parser::ParseError;
 pub use parser::Parser;

crates/djls-templates/src/nodelist.rs

@@ -1,6 +1,7 @@
 use djls_source::Span;
 
 use crate::db::Db as TemplateDb;
+use crate::parser::ParseError;
 
 #[salsa::tracked(debug)]
 pub struct NodeList<'db> {
@@ -28,6 +29,9 @@ pub enum Node<'db> {
         filters: Vec<FilterName<'db>>,
         span: Span,
     },
+    Error {
+        node: ErrorNode,
+    },
 }
 
 impl<'db> Node<'db> {
@@ -38,19 +42,23 @@ impl<'db> Node<'db> {
             | Node::Variable { span, .. }
             | Node::Comment { span, .. }
             | Node::Text { span } => *span,
+            Node::Error { node, .. } => node.span,
         }
     }
 
     #[must_use]
     pub fn full_span(&self) -> Span {
         match self {
             // account for delimiters
-            Node::Variable { span, .. } | Node::Comment { span, .. } | Node::Tag { span, .. } => {
+            Node::Variable { span, .. }
+            | Node::Comment { span, .. }
+            | Node::Tag { span, .. } => {
                 Span {
                     start: span.start.saturating_sub(3),
                     length: span.length + 6,
                 }
             }
+            Node::Error { node } => node.span,
             Node::Text { span } => *span,
         }
     }
@@ -73,11 +81,18 @@ impl<'db> Node<'db> {
                     length: u32::try_from(var_len).unwrap_or(0),
                 })
             }
-            Node::Comment { .. } | Node::Text { .. } => None,
+            Node::Comment { .. } | Node::Text { .. } | Node::Error { .. } => None,
         }
     }
 }
 
+#[derive(Clone, Debug, PartialEq, Eq, salsa::Update)]
+pub struct ErrorNode {
+    pub content: String,
+    pub span: Span,
+    pub error: ParseError,
+}
+
 #[salsa::interned(debug)]
 pub struct TagName<'db> {
     pub text: String,

crates/djls-templates/src/parser.rs

@@ -6,6 +6,7 @@ use thiserror::Error;
 use crate::db::Db as TemplateDb;
 use crate::db::TemplateErrorAccumulator;
 use crate::error::TemplateError;
+use crate::nodelist::ErrorNode;
 use crate::nodelist::FilterName;
 use crate::nodelist::Node;
 use crate::nodelist::NodeList;
@@ -41,7 +42,9 @@ impl<'db> Parser<'db> {
                     nodelist.push(node);
                 }
                 Err(err) => {
-                    self.report_error(&err);
+                    let error_node = self.build_error_node(err);
+                    nodelist.push(error_node);
+
                     if !self.is_at_end() {
                         self.synchronize()?;
                     }
@@ -239,6 +242,26 @@ impl<'db> Parser<'db> {
     fn report_error(&self, error: &ParseError) {
         TemplateErrorAccumulator(TemplateError::Parser(error.to_string())).accumulate(self.db);
     }
+
+    fn build_error_node(&self, error: ParseError) -> Node<'db> {
+        let token = self
+            .peek_previous()
+            .ok()
+            .or_else(|| self.peek().ok())
+            .map(|token| (span_from_token(token, self.db), token.lexeme(self.db)));
+
+        let (span, content) = token.unwrap_or_else(|| (Span::new(0, 0), String::new()));
+
+        self.report_error(&error);
+
+        Node::Error {
+            node: ErrorNode {
+                content,
+                span,
+                error,
+            },
+        }
+    }
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize)]
@@ -375,6 +398,11 @@ mod tests {
             filters: Vec<String>,
             span: (u32, u32),
         },
+        Error {
+            content: String,
+            span: (u32, u32),
+            error: ParseError,
+        },
     }
 
     impl TestNode {
@@ -397,6 +425,11 @@ mod tests {
                     filters: filters.iter().map(|f| f.text(db).to_string()).collect(),
                     span: (span.start, span.length),
                 },
+                Node::Error { node } => TestNode::Error {
+                    content: node.content.clone(),
+                    span: (node.span.start, node.span.length),
+                    error: node.error.clone(),
+                },
             }
         }
     }
@@ -711,6 +744,16 @@ mod tests {
             insta::assert_yaml_snapshot!(test_nodelist);
         }
 
+        #[test]
+        fn test_parse_unclosed_variable_token() {
+            let db = TestDatabase::new();
+            let source = "{{ user".to_string();
+            let template = TestTemplate::new(&db, source);
+            let nodelist = parse_test_template(&db, template);
+            let test_nodelist = convert_nodelist_for_testing_wrapper(nodelist, &db);
+            insta::assert_yaml_snapshot!(test_nodelist);
+        }
+
         // TODO: fix this so we can test against errors returned by parsing
         // #[test]
         // fn test_parse_error_recovery() {

crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_variable_token.snap

@@ -0,0 +1,14 @@
+---
+source: crates/djls-templates/src/parser.rs
+expression: test_nodelist
+---
+nodelist:
+  - type: Error
+    content: user
+    span:
+      - 3
+      - 4
+    error:
+      MalformedConstruct:
+        position: 3
+        content: user