fix: handle utf16 panics #820

Author: polarmutex

crates/lsp/src/providers/text_document.rs

@@ -433,16 +433,16 @@ pub(crate) fn did_change(
         // Convert UTF-16 column offsets to character offsets within the line
         // CRITICAL: range.start.character is UTF-16 offset *within the line*, not document-wide
         let start_line_utf16_cu = doc.content.char_to_utf16_cu(start_row_char_idx);
-        let start_col_char_idx = doc
-            .content
-            .utf16_cu_to_char(start_line_utf16_cu + range.start.character as usize)
-            - start_row_char_idx;
+        let start_utf16_idx = start_line_utf16_cu + range.start.character as usize;
+        // Clamp to document bounds to prevent panic if client sends invalid positions
+        let start_utf16_idx = start_utf16_idx.min(doc.content.len_utf16_cu());
+        let start_col_char_idx = doc.content.utf16_cu_to_char(start_utf16_idx) - start_row_char_idx;
 
         let end_line_utf16_cu = doc.content.char_to_utf16_cu(end_row_char_idx);
-        let end_col_char_idx = doc
-            .content
-            .utf16_cu_to_char(end_line_utf16_cu + range.end.character as usize)
-            - end_row_char_idx;
+        let end_utf16_idx = end_line_utf16_cu + range.end.character as usize;
+        // Clamp to document bounds to prevent panic if client sends invalid positions
+        let end_utf16_idx = end_utf16_idx.min(doc.content.len_utf16_cu());
+        let end_col_char_idx = doc.content.utf16_cu_to_char(end_utf16_idx) - end_row_char_idx;
 
         let start_char_idx = start_row_char_idx + start_col_char_idx;
         let end_char_idx = end_row_char_idx + end_col_char_idx;
@@ -904,4 +904,30 @@ mod tests {
             result
         );
     }
+
+    #[test]
+    fn test_out_of_bounds_utf16_position() {
+        // Test that out-of-bounds UTF-16 positions are clamped instead of panicking
+        // This reproduces issue #820 where neovim sends positions beyond document bounds
+        let content = "2023-01-01 * \"Test\"\n";
+        let doc = create_test_document(content);
+        let total_utf16_len = doc.content.len_utf16_cu();
+
+        // Simulate a change with end position beyond document bounds
+        let start_row_char_idx = doc.content.line_to_char(0);
+        let start_line_utf16_cu = doc.content.char_to_utf16_cu(start_row_char_idx);
+
+        // This should not panic - it should clamp to document end
+        let out_of_bounds_utf16 = total_utf16_len + 100;
+        let clamped_utf16 = out_of_bounds_utf16.min(doc.content.len_utf16_cu());
+        let result = doc
+            .content
+            .utf16_cu_to_char(start_line_utf16_cu + clamped_utf16);
+
+        // Should succeed and clamp to valid position
+        assert!(
+            result <= doc.content.len_chars(),
+            "Should clamp to valid char position"
+        );
+    }
 }

crates/lsp/src/treesitter_utils.rs

@@ -117,6 +117,8 @@ fn lsp_position_to_core(
     let row_char_idx = source.line_to_char(row_idx);
     let row_utf16_cu_idx = source.char_to_utf16_cu(row_char_idx);
     let abs_utf16_cu_idx = row_utf16_cu_idx + col_utf16_cu_idx;
+    // Clamp to document bounds to prevent panic if client sends invalid positions
+    let abs_utf16_cu_idx = abs_utf16_cu_idx.min(source.len_utf16_cu());
 
     // Convert absolute UTF-16 index -> absolute char index -> absolute byte index.
     let abs_char_idx = source.utf16_cu_to_char(abs_utf16_cu_idx);
@@ -397,4 +399,51 @@ mod tests {
         let text = text_for_tree_sitter_node(&source, &root);
         assert_eq!(text, "2024-01-01 * \"Coffee ☕\"");
     }
+
+    #[test]
+    fn test_lsp_position_out_of_bounds() {
+        // Test that out-of-bounds UTF-16 positions are clamped instead of panicking
+        // This reproduces issue #820
+        let source = Rope::from("2024-01-01 * \"Test\"\n");
+        let total_utf16_len = source.len_utf16_cu();
+
+        // Position beyond document bounds - should be clamped
+        let pos = Position::new(0, (total_utf16_len + 100) as u32);
+        let result = lsp_position_to_core(&source, pos);
+
+        // Should not panic, should clamp to document end
+        assert!(
+            result.is_ok(),
+            "Should handle out-of-bounds position gracefully"
+        );
+        let core_pos = result.unwrap();
+        assert_eq!(
+            core_pos.char as usize,
+            source.len_chars(),
+            "Should clamp to document end"
+        );
+    }
+
+    #[test]
+    fn test_lsp_textdocchange_out_of_bounds_range() {
+        // Test that text changes with out-of-bounds ranges don't panic
+        let source = Rope::from("Short text");
+        let total_utf16_len = source.len_utf16_cu();
+
+        // Change with end position beyond document - should be clamped
+        let change = TextDocumentContentChangeEvent {
+            range: Some(Range {
+                start: Position::new(0, 0),
+                end: Position::new(0, (total_utf16_len + 50) as u32),
+            }),
+            range_length: None,
+            text: "Replacement".to_string(),
+        };
+
+        let result = lsp_textdocchange_to_ts_inputedit(&source, &change);
+        assert!(
+            result.is_ok(),
+            "Should handle out-of-bounds range gracefully"
+        );
+    }
 }