span pair

joshuadavidthomas · joshuadavidthomas · commit 7bfc257af051 · 2025-09-16T23:50:38.000-05:00
diff --git a/crates/djls-templates/src/lexer.rs b/crates/djls-templates/src/lexer.rs
@@ -1,9 +1,9 @@
 use djls_source::Span;
 
 use crate::db::Db as TemplateDb;
+use crate::spans::SpanPair;
 use crate::tokens::Token;
 use crate::tokens::TokenContent;
-use crate::tokens::TokenSpans;
 
 const BLOCK_TAG_START: &str = "{%";
 const BLOCK_TAG_END: &str = "%}";
@@ -64,7 +64,7 @@ impl<'db> Lexer<'db> {
     fn lex_django_construct(
         &mut self,
         end: &str,
-        token_fn: impl FnOnce(TokenContent<'db>, TokenSpans) -> Token<'db>,
+        token_fn: impl FnOnce(TokenContent<'db>, SpanPair) -> Token<'db>,
     ) -> Token<'db> {
         let opening_len = 2;
         let content_start = self.start + opening_len;
@@ -79,7 +79,7 @@ impl<'db> Lexer<'db> {
                 self.consume_n(end.len());
                 let full_end = self.current;
                 let full_span = Span::from_bounds(self.start, full_end);
-                token_fn(content, TokenSpans::new(span, full_span))
+                token_fn(content, SpanPair::new(span, full_span))
             }
             Err(err_text) => {
                 let content_end = self.current;
@@ -88,7 +88,7 @@ impl<'db> Lexer<'db> {
                 let content = TokenContent::new(self.db, err_text);
                 Token::Error {
                     content,
-                    spans: TokenSpans::new(span, full_span),
+                    spans: SpanPair::new(span, full_span),
                 }
             }
         }
@@ -101,7 +101,7 @@ impl<'db> Lexer<'db> {
                 self.consume(); // \n of \r\n
             }
             let span = Span::from_bounds(self.start, self.current);
-            let spans = TokenSpans::new(span, span);
+            let spans = SpanPair::new(span, span);
             Token::Newline { spans }
         } else {
             self.consume(); // Consume the first whitespace
@@ -112,7 +112,7 @@ impl<'db> Lexer<'db> {
                 self.consume();
             }
             let span = Span::from_bounds(self.start, self.current);
-            let spans = TokenSpans::new(span, span);
+            let spans = SpanPair::new(span, span);
             Token::Whitespace { spans }
         }
     }
@@ -134,7 +134,7 @@ impl<'db> Lexer<'db> {
         let text = &self.source[text_start..self.current];
         let content = TokenContent::new(self.db, text.to_string());
         let span = Span::from_bounds(self.start, self.current);
-        let spans = TokenSpans::new(span, span);
+        let spans = SpanPair::new(span, span);
         Token::Text { content, spans }
     }
 
diff --git a/crates/djls-templates/src/lib.rs b/crates/djls-templates/src/lib.rs
@@ -50,6 +50,7 @@ mod error;
 mod lexer;
 pub mod nodelist;
 mod parser;
+mod spans;
 mod tokens;
 
 pub use db::Db;
@@ -64,6 +65,7 @@ pub use nodelist::NodeList;
 pub use parser::ParseError;
 pub use parser::Parser;
 use salsa::Accumulator;
+use spans::SpanPair;
 use tokens::TokenStream;
 
 /// Lex a template file into tokens.
@@ -108,12 +110,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 spans = SpanPair::new(span, span);
             let error_node = Node::Error {
-                node: ErrorNode {
-                    span,
-                    full_span: span,
-                    error: err,
-                },
+                node: ErrorNode { spans, error: err },
             };
 
             NodeList::new(db, vec![error_node])
diff --git a/crates/djls-templates/src/nodelist.rs b/crates/djls-templates/src/nodelist.rs
@@ -2,6 +2,7 @@ use djls_source::Span;
 
 use crate::db::Db as TemplateDb;
 use crate::parser::ParseError;
+use crate::spans::SpanPair;
 
 #[salsa::tracked(debug)]
 pub struct NodeList<'db> {
@@ -15,23 +16,19 @@ pub enum Node<'db> {
     Tag {
         name: TagName<'db>,
         bits: Vec<TagBit<'db>>,
-        span: Span,
-        full_span: Span,
+        spans: SpanPair,
     },
     Comment {
         content: String,
-        span: Span,
-        full_span: Span,
+        spans: SpanPair,
     },
     Text {
-        span: Span,
-        full_span: Span,
+        spans: SpanPair,
     },
     Variable {
         var: VariableName<'db>,
         filters: Vec<FilterName<'db>>,
-        span: Span,
-        full_span: Span,
+        spans: SpanPair,
     },
     Error {
         node: ErrorNode,
@@ -42,40 +39,40 @@ impl<'db> Node<'db> {
     #[must_use]
     pub fn span(&self) -> Span {
         match self {
-            Node::Tag { span, .. }
-            | Node::Variable { span, .. }
-            | Node::Comment { span, .. }
-            | Node::Text { span, .. } => *span,
-            Node::Error { node, .. } => node.span,
+            Node::Tag { spans, .. }
+            | Node::Variable { spans, .. }
+            | Node::Comment { spans, .. }
+            | Node::Text { spans, .. } => spans.content,
+            Node::Error { node, .. } => node.spans.content,
         }
     }
 
     #[must_use]
     pub fn full_span(&self) -> Span {
         match self {
-            Node::Variable { full_span, .. }
-            | Node::Comment { full_span, .. }
-            | Node::Tag { full_span, .. }
-            | Node::Text { full_span, .. } => *full_span,
-            Node::Error { node } => node.full_span,
+            Node::Variable { spans, .. }
+            | Node::Comment { spans, .. }
+            | Node::Tag { spans, .. }
+            | Node::Text { spans, .. } => spans.lexeme,
+            Node::Error { node } => node.spans.lexeme,
         }
     }
 
     pub fn identifier_span(&self, db: &'db dyn TemplateDb) -> Option<Span> {
         match self {
-            Node::Tag { name, span, .. } => {
+            Node::Tag { name, spans, .. } => {
                 // Just the tag name (e.g., "if" in "{% if user.is_authenticated %}")
                 let name_len = name.text(db).len();
                 Some(Span {
-                    start: span.start,
+                    start: spans.content.start,
                     length: u32::try_from(name_len).unwrap_or(0),
                 })
             }
-            Node::Variable { var, span, .. } => {
+            Node::Variable { var, spans, .. } => {
                 // Just the variable name (e.g., "user" in "{{ user.name|title }}")
                 let var_len = var.text(db).len();
                 Some(Span {
-                    start: span.start,
+                    start: spans.content.start,
                     length: u32::try_from(var_len).unwrap_or(0),
                 })
             }
@@ -86,8 +83,7 @@ impl<'db> Node<'db> {
 
 #[derive(Clone, Debug, PartialEq, Eq, salsa::Update)]
 pub struct ErrorNode {
-    pub span: Span,
-    pub full_span: Span,
+    pub spans: SpanPair,
     pub error: ParseError,
 }
 
diff --git a/crates/djls-templates/src/parser.rs b/crates/djls-templates/src/parser.rs
@@ -13,6 +13,7 @@ use crate::nodelist::NodeList;
 use crate::nodelist::TagBit;
 use crate::nodelist::TagName;
 use crate::nodelist::VariableName;
+use crate::spans::SpanPair;
 use crate::tokens::span_from_token;
 use crate::tokens::Token;
 use crate::tokens::TokenStream;
@@ -76,10 +77,10 @@ impl<'db> Parser<'db> {
         let token = self.peek_previous()?;
 
         let span = span_from_token(token, self.db);
+        let full_span = token.full_span().unwrap_or(span);
         Ok(Node::Comment {
             content: token.content(self.db),
-            span,
-            full_span: token.full_span().unwrap_or(span),
+            spans: SpanPair::new(span, full_span),
         })
     }
 
@@ -125,8 +126,7 @@ impl<'db> Parser<'db> {
         Ok(Node::Tag {
             name,
             bits,
-            span,
-            full_span,
+            spans: SpanPair::new(span, full_span),
         })
     }
 
@@ -160,8 +160,7 @@ impl<'db> Parser<'db> {
         Ok(Node::Variable {
             var,
             filters,
-            span,
-            full_span,
+            spans: SpanPair::new(span, full_span),
         })
     }
 
@@ -196,8 +195,7 @@ impl<'db> Parser<'db> {
         let span = Span::new(start, length);
 
         Ok(Node::Text {
-            span,
-            full_span: span,
+            spans: SpanPair::new(span, span),
         })
     }
 
@@ -265,22 +263,18 @@ impl<'db> Parser<'db> {
             .map(|token| {
                 let span = span_from_token(token, self.db);
                 let full_span = token.full_span().unwrap_or(span);
-                (span, full_span)
+                SpanPair::new(span, full_span)
             });
 
-        let (span, full_span) = spans.unwrap_or_else(|| {
+        let spans = spans.unwrap_or_else(|| {
             let empty = Span::new(0, 0);
-            (empty, empty)
+            SpanPair::new(empty, empty)
         });
 
         self.report_error(&error);
 
         Node::Error {
-            node: ErrorNode {
-                span,
-                full_span,
-                error,
-            },
+            node: ErrorNode { spans, error },
         }
     }
 }
@@ -433,44 +427,34 @@ mod tests {
     impl TestNode {
         fn from_node(node: &Node<'_>, db: &dyn crate::db::Db) -> Self {
             match node {
-                Node::Tag {
-                    name,
-                    bits,
-                    span,
-                    full_span,
-                } => TestNode::Tag {
+                Node::Tag { name, bits, spans } => TestNode::Tag {
                     name: name.text(db).to_string(),
                     bits: bits.iter().map(|b| b.text(db).to_string()).collect(),
-                    span: (span.start, span.length),
-                    full_span: (full_span.start, full_span.length),
+                    span: spans.content_tuple(),
+                    full_span: spans.lexeme_tuple(),
                 },
-                Node::Comment {
-                    content,
-                    span,
-                    full_span,
-                } => TestNode::Comment {
+                Node::Comment { content, spans } => TestNode::Comment {
                     content: content.clone(),
-                    span: (span.start, span.length),
-                    full_span: (full_span.start, full_span.length),
+                    span: spans.content_tuple(),
+                    full_span: spans.lexeme_tuple(),
                 },
-                Node::Text { span, full_span } => TestNode::Text {
-                    span: (span.start, span.length),
-                    full_span: (full_span.start, full_span.length),
+                Node::Text { spans } => TestNode::Text {
+                    span: spans.content_tuple(),
+                    full_span: spans.lexeme_tuple(),
                 },
                 Node::Variable {
                     var,
                     filters,
-                    span,
-                    full_span,
+                    spans,
                 } => TestNode::Variable {
                     var: var.text(db).to_string(),
                     filters: filters.iter().map(|f| f.text(db).to_string()).collect(),
-                    span: (span.start, span.length),
-                    full_span: (full_span.start, full_span.length),
+                    span: spans.content_tuple(),
+                    full_span: spans.lexeme_tuple(),
                 },
                 Node::Error { node } => TestNode::Error {
-                    span: (node.span.start, node.span.length),
-                    full_span: (node.full_span.start, node.full_span.length),
+                    span: node.spans.content_tuple(),
+                    full_span: node.spans.lexeme_tuple(),
                     error: node.error.clone(),
                 },
             }
diff --git a/crates/djls-templates/src/spans.rs b/crates/djls-templates/src/spans.rs
@@ -0,0 +1,24 @@
+use djls_source::Span;
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, salsa::Update)]
+pub struct SpanPair {
+    pub content: Span,
+    pub lexeme: Span,
+}
+
+impl SpanPair {
+    #[must_use]
+    pub fn new(content: Span, lexeme: Span) -> Self {
+        Self { content, lexeme }
+    }
+
+    #[must_use]
+    pub fn content_tuple(&self) -> (u32, u32) {
+        (self.content.start, self.content.length)
+    }
+
+    #[must_use]
+    pub fn lexeme_tuple(&self) -> (u32, u32) {
+        (self.lexeme.start, self.lexeme.length)
+    }
+}
diff --git a/crates/djls-templates/src/tokens.rs b/crates/djls-templates/src/tokens.rs
