inline enum fields instead of a separate struct

Author: joshuadavidthomas

crates/djls-templates/src/lib.rs

@@ -58,7 +58,6 @@ use djls_source::File;
 use djls_source::FileKind;
 pub use error::TemplateError;
 pub use lexer::Lexer;
-pub use nodelist::ErrorNode;
 use nodelist::Node;
 pub use nodelist::NodeList;
 pub use parser::ParseError;
@@ -109,11 +108,9 @@ pub fn parse_template(db: &dyn Db, file: File) -> Option<NodeList<'_>> {
             let text = source.as_ref();
             let span = djls_source::Span::from_bounds(0, text.len());
             let error_node = Node::Error {
-                node: ErrorNode {
-                    span,
-                    full_span: span,
-                    error: err,
-                },
+                span,
+                full_span: span,
+                error: err,
             };
 
             NodeList::new(db, vec![error_node])

crates/djls-templates/src/nodelist.rs

@@ -31,7 +31,9 @@ pub enum Node<'db> {
         span: Span,
     },
     Error {
-        node: ErrorNode,
+        span: Span,
+        full_span: Span,
+        error: ParseError,
     },
 }
 
@@ -42,8 +44,8 @@ impl<'db> Node<'db> {
             Node::Tag { span, .. }
             | Node::Variable { span, .. }
             | Node::Comment { span, .. }
-            | Node::Text { span, .. } => *span,
-            Node::Error { node, .. } => node.span,
+            | Node::Text { span, .. }
+            | Node::Error { span, .. } => *span,
         }
     }
 
@@ -54,7 +56,7 @@ impl<'db> Node<'db> {
                 span.expand(TagDelimiter::LENGTH_U32, TagDelimiter::LENGTH_U32)
             }
             Node::Text { span, .. } => *span,
-            Node::Error { node } => node.full_span,
+            Node::Error { full_span, .. } => *full_span,
         }
     }
 
@@ -81,13 +83,6 @@ impl<'db> Node<'db> {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, salsa::Update)]
-pub struct ErrorNode {
-    pub span: Span,
-    pub full_span: Span,
-    pub error: ParseError,
-}
-
 #[salsa::interned(debug)]
 pub struct TagName<'db> {
     pub text: String,

crates/djls-templates/src/parser.rs

@@ -6,7 +6,6 @@ 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;
@@ -50,22 +49,16 @@ impl<'db> Parser<'db> {
                                 let empty = Span::new(0, 0);
                                 (empty, empty)
                             },
-                            |token| {
-                                let content_span = token.to_span(self.db);
-                                let full_span = token.full_span().unwrap_or(content_span);
-                                (content_span, full_span)
-                            },
+                            |error_tok| error_tok.spans(self.db),
                         );
 
                     TemplateErrorAccumulator(TemplateError::Parser(error.to_string()))
                         .accumulate(self.db);
 
                     nodelist.push(Node::Error {
-                        node: ErrorNode {
-                            span,
-                            full_span,
-                            error,
-                        },
+                        span,
+                        full_span,
+                        error,
                     });
 
                     if !self.is_at_end() {
@@ -114,15 +107,15 @@ impl<'db> Parser<'db> {
         let name = TagName::new(self.db, name_str.to_string());
 
         let bits = parts.map(|s| TagBit::new(self.db, s.to_string())).collect();
-        let span = token.to_span(self.db);
+        let span = token.content_span_or_fallback(self.db);
 
         Ok(Node::Tag { name, bits, span })
     }
 
     fn parse_comment(&mut self) -> Result<Node<'db>, ParseError> {
         let token = self.peek_previous()?;
 
-        let span = token.to_span(self.db);
+        let span = token.content_span_or_fallback(self.db);
         Ok(Node::Comment {
             content: token.content(self.db),
             span,
@@ -151,7 +144,7 @@ impl<'db> Parser<'db> {
         let first_token = self.peek_previous()?;
         let first_span = first_token
             .full_span()
-            .unwrap_or_else(|| first_token.to_span(self.db));
+            .unwrap_or_else(|| first_token.content_span_or_fallback(self.db));
         let start = first_span.start;
         let mut end = first_span.start + first_span.length;
 
@@ -164,7 +157,9 @@ impl<'db> Parser<'db> {
                 | Token::Eof { .. } => break, // Stop at Django constructs
                 Token::Text { .. } | Token::Whitespace { .. } | Token::Newline { .. } => {
                     // Update end position
-                    let token_span = token.full_span().unwrap_or_else(|| token.to_span(self.db));
+                    let token_span = token
+                        .full_span()
+                        .unwrap_or_else(|| token.content_span_or_fallback(self.db));
                     let token_end = token_span.start + token_span.length;
                     end = end.max(token_end);
                     self.consume()?;
@@ -202,7 +197,7 @@ impl<'db> Parser<'db> {
                 FilterName::new(self.db, trimmed.to_string())
             })
             .collect();
-        let span = token.to_span(self.db);
+        let span = token.content_span_or_fallback(self.db);
 
         Ok(Node::Variable { var, filters, span })
     }
@@ -429,10 +424,14 @@ mod tests {
                     span: span.as_tuple(),
                     full_span: node.full_span().as_tuple(),
                 },
-                Node::Error { node } => TestNode::Error {
-                    span: node.span.as_tuple(),
-                    full_span: node.full_span.as_tuple(),
-                    error: node.error.clone(),
+                Node::Error {
+                    span,
+                    full_span,
+                    error,
+                } => TestNode::Error {
+                    span: span.as_tuple(),
+                    full_span: full_span.as_tuple(),
+                    error: error.clone(),
                 },
             }
         }

crates/djls-templates/src/tokens.rs

@@ -77,11 +77,6 @@ pub struct TokenContent<'db> {
 }
 
 impl<'db> Token<'db> {
-    pub fn to_span(&self, db: &dyn TemplateDb) -> Span {
-        self.content_span()
-            .unwrap_or_else(|| Span::new(self.offset().unwrap_or(0), self.length(db)))
-    }
-
     /// Get the content text for content-bearing tokens
     pub fn content(&self, db: &'db dyn TemplateDb) -> String {
         match self {
@@ -177,6 +172,17 @@ impl<'db> Token<'db> {
             Token::Eof => None,
         }
     }
+
+    pub fn content_span_or_fallback(&self, db: &dyn TemplateDb) -> Span {
+        self.content_span()
+            .unwrap_or_else(|| Span::new(self.offset().unwrap_or(0), self.length(db)))
+    }
+
+    pub fn spans(&self, db: &'db dyn TemplateDb) -> (Span, Span) {
+        let content = self.content_span_or_fallback(db);
+        let full = self.full_span().unwrap_or(content);
+        (content, full)
+    }
 }
 
 #[cfg(test)]