Record parser errors in NodeList to preserve source fidelity (#239)

Author: joshuadavidthomas

crates/djls-ide/src/diagnostics.rs

@@ -33,13 +33,13 @@ impl DiagnosticError for ValidationError {
     fn span(&self) -> Option<(u32, u32)> {
         match self {
             ValidationError::UnbalancedStructure { opening_span, .. } => {
-                Some((opening_span.start, opening_span.length))
+                Some(opening_span.as_tuple())
             }
             ValidationError::UnclosedTag { span, .. }
             | ValidationError::OrphanedTag { span, .. }
             | ValidationError::UnmatchedBlockName { span, .. }
             | ValidationError::MissingRequiredArguments { span, .. }
-            | ValidationError::TooManyArguments { span, .. } => Some((span.start, span.length)),
+            | ValidationError::TooManyArguments { span, .. } => Some(span.as_tuple()),
         }
     }
 

crates/djls-source/src/position.rs

@@ -2,28 +2,53 @@ use serde::Serialize;
 
 /// A byte offset within a text document.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize)]
-pub struct ByteOffset(pub u32);
+pub struct ByteOffset(u32);
+
+impl ByteOffset {
+    #[must_use]
+    pub fn new(offset: u32) -> Self {
+        Self(offset)
+    }
+
+    #[must_use]
+    pub fn from_usize(offset: usize) -> Self {
+        Self(u32::try_from(offset).unwrap_or(u32::MAX))
+    }
+
+    #[must_use]
+    pub fn offset(&self) -> u32 {
+        self.0
+    }
+}
 
 /// A line and column position within a text document.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct LineCol(pub (u32, u32));
+pub struct LineCol {
+    line: u32,
+    column: u32,
+}
 
 impl LineCol {
+    #[must_use]
+    pub fn new(line: u32, column: u32) -> Self {
+        Self { line, column }
+    }
+
     #[must_use]
     pub fn line(&self) -> u32 {
-        self.0 .0
+        self.line
     }
 
     #[must_use]
     pub fn column(&self) -> u32 {
-        self.0 .1
+        self.column
     }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize)]
 pub struct Span {
-    pub start: u32,
-    pub length: u32,
+    start: u32,
+    length: u32,
 }
 
 impl Span {
@@ -32,6 +57,61 @@ impl Span {
         Self { start, length }
     }
 
+    #[must_use]
+    pub fn from_parts(start: usize, length: usize) -> Self {
+        let start_u32 = u32::try_from(start).unwrap_or(u32::MAX);
+        let length_u32 = u32::try_from(length).unwrap_or(u32::MAX.saturating_sub(start_u32));
+        Span::new(start_u32, length_u32)
+    }
+
+    #[must_use]
+    pub fn with_length_usize(self, length: usize) -> Self {
+        Self::from_parts(self.start_usize(), length)
+    }
+
+    /// Construct a span from integer bounds expressed as byte offsets.
+    #[must_use]
+    pub fn from_bounds(start: usize, end: usize) -> Self {
+        Self::from_parts(start, end.saturating_sub(start))
+    }
+
+    #[must_use]
+    pub fn expand(self, opening: u32, closing: u32) -> Self {
+        let start_expand = self.start.saturating_sub(opening);
+        let length_expand = opening + self.length + closing;
+        Self::new(start_expand, length_expand)
+    }
+
+    #[must_use]
+    pub fn as_tuple(self) -> (u32, u32) {
+        (self.start, self.length)
+    }
+
+    #[must_use]
+    pub fn start(self) -> u32 {
+        self.start
+    }
+
+    #[must_use]
+    pub fn start_usize(self) -> usize {
+        self.start as usize
+    }
+
+    #[must_use]
+    pub fn end(self) -> u32 {
+        self.start + self.length
+    }
+
+    #[must_use]
+    pub fn length(self) -> u32 {
+        self.length
+    }
+
+    #[must_use]
+    pub fn length_usize(self) -> usize {
+        self.length as usize
+    }
+
     #[must_use]
     pub fn start_offset(&self) -> ByteOffset {
         ByteOffset(self.start)
@@ -91,7 +171,7 @@ impl LineIndex {
     #[must_use]
     pub fn to_line_col(&self, offset: ByteOffset) -> LineCol {
         if self.0.is_empty() {
-            return LineCol((0, 0));
+            return LineCol::new(0, 0);
         }
 
         let line = match self.0.binary_search(&offset.0) {
@@ -103,7 +183,7 @@ impl LineIndex {
         let line_start = self.0[line];
         let column = offset.0.saturating_sub(line_start);
 
-        LineCol((u32::try_from(line).unwrap_or_default(), column))
+        LineCol::new(u32::try_from(line).unwrap_or_default(), column)
     }
 
     #[must_use]
@@ -160,8 +240,8 @@ mod tests {
         let index = LineIndex::from_text(text);
 
         // "hello" is 5 bytes, then \r\n, so "world" starts at byte 7
-        assert_eq!(index.to_line_col(ByteOffset(0)), LineCol((0, 0)));
-        assert_eq!(index.to_line_col(ByteOffset(7)), LineCol((1, 0)));
-        assert_eq!(index.to_line_col(ByteOffset(8)), LineCol((1, 1)));
+        assert_eq!(index.to_line_col(ByteOffset(0)), LineCol::new(0, 0));
+        assert_eq!(index.to_line_col(ByteOffset(7)), LineCol::new(1, 0));
+        assert_eq!(index.to_line_col(ByteOffset(8)), LineCol::new(1, 1));
     }
 }

crates/djls-source/src/protocol.rs

@@ -60,10 +60,10 @@ impl PositionEncoding {
     /// // UTF-16: "Hello " (6) + "🌍" (2 UTF-16 units) = position 8
     /// let offset = PositionEncoding::Utf16.line_col_to_offset(
     ///     &index,
-    ///     LineCol((0, 8)),
+    ///     LineCol::new(0, 8),
     ///     text
     /// );
-    /// assert_eq!(offset, Some(ByteOffset(10))); // "Hello 🌍" is 10 bytes
+    /// assert_eq!(offset, Some(ByteOffset::new(10))); // "Hello 🌍" is 10 bytes
     /// ```
     #[must_use]
     pub fn line_col_to_offset(
@@ -78,11 +78,11 @@ impl PositionEncoding {
         // Handle line bounds - if line > line_count, return document length
         let line_start_utf8 = match index.lines().get(line as usize) {
             Some(start) => *start,
-            None => return Some(ByteOffset(u32::try_from(text.len()).unwrap_or(u32::MAX))),
+            None => return Some(ByteOffset::from_usize(text.len())),
         };
 
         if character == 0 {
-            return Some(ByteOffset(line_start_utf8));
+            return Some(ByteOffset::new(line_start_utf8));
         }
 
         let next_line_start = index
@@ -96,14 +96,14 @@ impl PositionEncoding {
         // Fast path optimization for ASCII text, all encodings are equivalent to byte offsets
         if line_text.is_ascii() {
             let char_offset = character.min(u32::try_from(line_text.len()).unwrap_or(u32::MAX));
-            return Some(ByteOffset(line_start_utf8 + char_offset));
+            return Some(ByteOffset::new(line_start_utf8 + char_offset));
         }
 
         match self {
             PositionEncoding::Utf8 => {
                 // UTF-8: character positions are already byte offsets
                 let char_offset = character.min(u32::try_from(line_text.len()).unwrap_or(u32::MAX));
-                Some(ByteOffset(line_start_utf8 + char_offset))
+                Some(ByteOffset::new(line_start_utf8 + char_offset))
             }
             PositionEncoding::Utf16 => {
                 // UTF-16: count UTF-16 code units
@@ -119,7 +119,7 @@ impl PositionEncoding {
                 }
 
                 // If character position exceeds line length, clamp to line end
-                Some(ByteOffset(line_start_utf8 + utf8_pos))
+                Some(ByteOffset::new(line_start_utf8 + utf8_pos))
             }
             PositionEncoding::Utf32 => {
                 // UTF-32: count Unicode code points (characters)
@@ -133,7 +133,7 @@ impl PositionEncoding {
                 }
 
                 // If character position exceeds line length, clamp to line end
-                Some(ByteOffset(line_start_utf8 + utf8_pos))
+                Some(ByteOffset::new(line_start_utf8 + utf8_pos))
             }
         }
     }
@@ -158,15 +158,15 @@ mod tests {
         // "Hello " = 6 UTF-16 units, "🌍" = 2 UTF-16 units
         // So position (0, 8) in UTF-16 should be after the emoji
         let offset = PositionEncoding::Utf16
-            .line_col_to_offset(&index, LineCol((0, 8)), text)
+            .line_col_to_offset(&index, LineCol::new(0, 8), text)
             .expect("Should get offset");
-        assert_eq!(offset, ByteOffset(10)); // "Hello 🌍" is 10 bytes
+        assert_eq!(offset, ByteOffset::new(10)); // "Hello 🌍" is 10 bytes
 
         // In UTF-8, character 10 would be at the 'r' in 'world'
         let offset_utf8 = PositionEncoding::Utf8
-            .line_col_to_offset(&index, LineCol((0, 10)), text)
+            .line_col_to_offset(&index, LineCol::new(0, 10), text)
             .expect("Should get offset");
-        assert_eq!(offset_utf8, ByteOffset(10));
+        assert_eq!(offset_utf8, ByteOffset::new(10));
     }
 
     #[test]
@@ -176,17 +176,17 @@ mod tests {
 
         // For ASCII text, all encodings should give the same result
         let offset_utf8 = PositionEncoding::Utf8
-            .line_col_to_offset(&index, LineCol((0, 5)), text)
+            .line_col_to_offset(&index, LineCol::new(0, 5), text)
             .expect("Should get offset");
         let offset_utf16 = PositionEncoding::Utf16
-            .line_col_to_offset(&index, LineCol((0, 5)), text)
+            .line_col_to_offset(&index, LineCol::new(0, 5), text)
             .expect("Should get offset");
         let offset_utf32 = PositionEncoding::Utf32
-            .line_col_to_offset(&index, LineCol((0, 5)), text)
+            .line_col_to_offset(&index, LineCol::new(0, 5), text)
             .expect("Should get offset");
 
-        assert_eq!(offset_utf8, ByteOffset(5));
-        assert_eq!(offset_utf16, ByteOffset(5));
-        assert_eq!(offset_utf32, ByteOffset(5));
+        assert_eq!(offset_utf8, ByteOffset::new(5));
+        assert_eq!(offset_utf16, ByteOffset::new(5));
+        assert_eq!(offset_utf32, ByteOffset::new(5));
     }
 }