reshuffle! CHANGE PLACES

Author: joshuadavidthomas

crates/djls-ide/src/diagnostics.rs

@@ -57,17 +57,16 @@ impl DiagnosticError for ValidationError {
 
 /// Convert a Span to an LSP Range using line offsets.
 fn span_to_lsp_range(span: Span, line_index: &LineIndex) -> lsp_types::Range {
-    let (start_line, start_char) = line_index.to_line_col(span.start);
-    let (end_line, end_char) = line_index.to_line_col(span.start.saturating_add(span.length));
+    let (start_pos, end_pos) = span.to_line_col(line_index);
 
     lsp_types::Range {
         start: lsp_types::Position {
-            line: start_line,
-            character: start_char,
+            line: start_pos.line(),
+            character: start_pos.column(),
         },
         end: lsp_types::Position {
-            line: end_line,
-            character: end_char,
+            line: end_pos.line(),
+            character: end_pos.column(),
         },
     }
 }

crates/djls-source/src/file.rs

@@ -5,6 +5,7 @@ use camino::Utf8Path;
 use camino::Utf8PathBuf;
 
 use crate::db::Db;
+use crate::position::LineIndex;
 
 #[salsa::input]
 pub struct File {
@@ -116,48 +117,3 @@ impl FileKind {
         }
     }
 }
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct LineIndex(Vec<u32>);
-
-impl LineIndex {
-    #[must_use]
-    pub fn from_text(text: &str) -> Self {
-        let mut starts = Vec::with_capacity(256);
-        starts.push(0);
-        for (i, b) in text.bytes().enumerate() {
-            if b == b'\n' {
-                starts.push(u32::try_from(i).unwrap_or_default() + 1);
-            }
-        }
-        LineIndex(starts)
-    }
-
-    #[must_use]
-    pub fn to_line_col(&self, offset: u32) -> (u32, u32) {
-        if self.0.is_empty() {
-            return (0, 0);
-        }
-
-        let line = match self.0.binary_search(&offset) {
-            Ok(exact) => exact,
-            Err(0) => 0,
-            Err(next) => next - 1,
-        };
-
-        let line_start = self.0[line];
-        let column = offset.saturating_sub(line_start);
-
-        (u32::try_from(line).unwrap_or_default(), column)
-    }
-
-    #[must_use]
-    pub fn line_start(&self, line: u32) -> Option<u32> {
-        self.0.get(line as usize).copied()
-    }
-
-    #[must_use]
-    pub fn lines(&self) -> &[u32] {
-        &self.0
-    }
-}

crates/djls-source/src/lib.rs

@@ -1,9 +1,11 @@
 mod db;
 mod file;
-mod span;
+mod position;
 
 pub use db::Db;
 pub use file::File;
 pub use file::FileKind;
-pub use file::LineIndex;
-pub use span::Span;
+pub use position::ByteOffset;
+pub use position::LineCol;
+pub use position::LineIndex;
+pub use position::Span;

crates/djls-source/src/position.rs

@@ -0,0 +1,97 @@
+use serde::Serialize;
+
+/// A byte offset within a text document.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize)]
+pub struct ByteOffset(pub u32);
+
+/// A line and column position within a text document.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct LineCol(pub (u32, u32));
+
+impl LineCol {
+    #[must_use]
+    pub fn line(&self) -> u32 {
+        self.0 .0
+    }
+
+    #[must_use]
+    pub fn column(&self) -> u32 {
+        self.0 .1
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize)]
+pub struct Span {
+    pub start: u32,
+    pub length: u32,
+}
+
+impl Span {
+    #[must_use]
+    pub fn new(start: u32, length: u32) -> Self {
+        Self { start, length }
+    }
+
+    #[must_use]
+    pub fn start_offset(&self) -> ByteOffset {
+        ByteOffset(self.start)
+    }
+
+    #[must_use]
+    pub fn end_offset(&self) -> ByteOffset {
+        ByteOffset(self.start.saturating_add(self.length))
+    }
+
+    /// Convert this span to start and end line/column positions using the given line index.
+    #[must_use]
+    pub fn to_line_col(&self, line_index: &LineIndex) -> (LineCol, LineCol) {
+        let start = line_index.to_line_col(self.start_offset());
+        let end = line_index.to_line_col(self.end_offset());
+        (start, end)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct LineIndex(Vec<u32>);
+
+impl LineIndex {
+    #[must_use]
+    pub fn from_text(text: &str) -> Self {
+        let mut starts = Vec::with_capacity(256);
+        starts.push(0);
+        for (i, b) in text.bytes().enumerate() {
+            if b == b'\n' {
+                starts.push(u32::try_from(i).unwrap_or_default() + 1);
+            }
+        }
+        LineIndex(starts)
+    }
+
+    #[must_use]
+    pub fn to_line_col(&self, offset: ByteOffset) -> LineCol {
+        if self.0.is_empty() {
+            return LineCol((0, 0));
+        }
+
+        let line = match self.0.binary_search(&offset.0) {
+            Ok(exact) => exact,
+            Err(0) => 0,
+            Err(next) => next - 1,
+        };
+
+        let line_start = self.0[line];
+        let column = offset.0.saturating_sub(line_start);
+
+        LineCol((u32::try_from(line).unwrap_or_default(), column))
+    }
+
+    #[must_use]
+    pub fn line_start(&self, line: u32) -> Option<u32> {
+        self.0.get(line as usize).copied()
+    }
+
+    #[must_use]
+    pub fn lines(&self) -> &[u32] {
+        &self.0
+    }
+}

crates/djls-source/src/span.rs

@@ -150,12 +150,6 @@ impl TextDocument {
         self.offset_for_position_with_text(position, &self.content, encoding)
     }
 
-    #[must_use]
-    pub fn offset_to_position(&self, offset: u32) -> Position {
-        let (line, character) = self.line_index.to_line_col(offset);
-        Position::new(line, character)
-    }
-
     /// Convert position to text offset using the specified encoding.
     ///
     /// Returns a valid offset, clamping out-of-bounds positions to document/line boundaries.

crates/djls-workspace/src/document.rs

@@ -340,8 +340,14 @@ mod tests {
         assert_eq!(source.as_str(), document.content());
 
         let line_index = file.line_index(&db);
-        assert_eq!(line_index.to_line_col(0), (0, 0));
-        assert_eq!(line_index.to_line_col(6), (1, 0));
+        assert_eq!(
+            line_index.to_line_col(djls_source::ByteOffset(0)),
+            djls_source::LineCol((0, 0))
+        );
+        assert_eq!(
+            line_index.to_line_col(djls_source::ByteOffset(6)),
+            djls_source::LineCol((1, 0))
+        );
     }
 
     #[test]