Fix unicode

Author: CppCXY

crates/emmylua_check/src/terminal_display/display.rs

@@ -1,6 +1,6 @@
 use std::path::PathBuf;
 
-use emmylua_code_analysis::{DbIndex, FileId};
+use emmylua_code_analysis::{DbIndex, FileId, LuaDocument};
 use lsp_types::{Diagnostic, DiagnosticSeverity};
 
 #[derive(Debug)]
@@ -32,6 +32,7 @@ impl TerminalDisplay {
         let file_path = self.get_relative_path(db, file_id);
         let document = db.get_vfs().get_document(&file_id).unwrap();
         let text = document.get_text();
+        let text_lines = text.lines().collect::<Vec<&str>>();
 
         // Group statistics by severity level
         let mut error_count = 0;
@@ -60,7 +61,7 @@ impl TerminalDisplay {
 
         // Display each diagnostic individually
         for diagnostic in diagnostics {
-            self.display_single_diagnostic(&file_path, text, diagnostic, db, file_id);
+            self.display_single_diagnostic(&file_path, &document, &text_lines, diagnostic);
         }
 
         println!(); // Add blank line separator
@@ -162,18 +163,11 @@ impl TerminalDisplay {
     fn display_single_diagnostic(
         &mut self,
         file_path: &str,
-        text: &str,
+        document: &LuaDocument,
+        lines: &[&str],
         diagnostic: Diagnostic,
-        document: &emmylua_code_analysis::DbIndex,
-        file_id: FileId,
     ) {
         let range = diagnostic.range;
-        let doc = document.get_vfs().get_document(&file_id).unwrap();
-        let _span = match doc.get_range_span(range) {
-            Some(span) => span,
-            None => return,
-        };
-
         // Get severity level colors and symbols
         let (level_color, level_symbol, _level_name) = match diagnostic.severity {
             Some(DiagnosticSeverity::ERROR) => ("\x1b[1;31m", "error", "error"),
@@ -194,12 +188,17 @@ impl TerminalDisplay {
 
         // Calculate line and column numbers
         let start_line = range.start.line as usize;
-        let start_col = range.start.character as usize;
+        let start_character = range.start.character as usize;
+        let Some(start_col) = document.get_col_offset_at_line(start_line, start_character) else {
+            return;
+        };
+        let start_col = u32::from(start_col) as usize;
         let end_line = range.end.line as usize;
-        let end_col = range.end.character as usize;
-
-        // Split text into lines
-        let lines: Vec<&str> = text.lines().collect();
+        let end_character = range.end.character as usize;
+        let Some(end_col) = document.get_col_offset_at_line(end_line, end_character) else {
+            return;
+        };
+        let end_col = u32::from(end_col) as usize;
 
         if start_line >= lines.len() {
             return;
@@ -226,10 +225,15 @@ impl TerminalDisplay {
                 "  \x1b[90m-->\x1b[0m {}:{}:{}",
                 file_path,
                 start_line + 1,
-                start_col + 1
+                start_character + 1
             );
         } else {
-            println!("  --> {}:{}:{}", file_path, start_line + 1, start_col + 1);
+            println!(
+                "  --> {}:{}:{}",
+                file_path,
+                start_line + 1,
+                start_character + 1
+            );
         }
 
         // Calculate context range to display (one line before and after for context)

crates/emmylua_code_analysis/src/vfs/document.rs

@@ -73,6 +73,10 @@ impl<'a> LuaDocument<'a> {
         self.line_index.get_offset(line, col, self.text)
     }
 
+    pub fn get_col_offset_at_line(&self, line: usize, col: usize) -> Option<TextSize> {
+        self.line_index.get_col_offset_at_line(line, col, self.text)
+    }
+
     pub fn get_line_range(&self, line: usize) -> Option<TextRange> {
         let start = self.line_index.get_line_offset(line)?;
         if let Some(end) = self.line_index.get_line_offset(line + 1) {
@@ -135,30 +139,13 @@ impl<'a> LuaDocument<'a> {
             },
         }
     }
-
-    pub fn get_range_span(&self, range: lsp_types::Range) -> Option<(usize, usize)> {
-        let text = self.get_text();
-        let start = self.get_offset(range.start.line as usize, range.start.character as usize)?;
-        let end = self.get_offset(range.end.line as usize, range.end.character as usize)?;
-        // char count
-        let start = text
-            .get(..start.into())
-            .map(|s| s.chars().count())
-            .unwrap_or(0);
-        let end = text
-            .get(..end.into())
-            .map(|s| s.chars().count())
-            .unwrap_or(0);
-
-        Some((start.into(), end.into()))
-    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::{Emmyrc, Vfs, VirtualUrlGenerator};
-    use lsp_types::{Position, Range};
+    use lsp_types::Position;
 
     fn create_vfs() -> Vfs {
         let mut vfs = Vfs::new();
@@ -240,30 +227,6 @@ mod tests {
         assert_eq!(rowan_range.end(), TextSize::from(11));
     }
 
-    #[test]
-    fn test_range_span() {
-        let code = "abcde";
-        let mut vfs = create_vfs();
-        let vg = VirtualUrlGenerator::new();
-        let uri = vg.new_uri("span.lua");
-        let id = vfs.set_file_content(&uri, Some(code.to_string()));
-        let document = vfs.get_document(&id).unwrap();
-
-        let lsp_range = Range {
-            start: Position {
-                line: 0,
-                character: 1,
-            },
-            end: Position {
-                line: 0,
-                character: 4,
-            },
-        };
-        let span = document.get_range_span(lsp_range).unwrap();
-        // Expecting span (1, 4) which corresponds to substring "bcd".
-        assert_eq!(span, (1, 4));
-    }
-
     #[test]
     fn test_file_name_and_uri() {
         let code = "";

crates/emmylua_parser/src/text/line_index.rs

@@ -128,4 +128,33 @@ impl LineIndex {
             Some(start_offset + TextSize::from(offset as u32))
         }
     }
+
+    pub fn get_col_offset_at_line(
+        &self,
+        line: usize,
+        col: usize,
+        source_text: &str,
+    ) -> Option<TextSize> {
+        let start_offset = self.get_line_offset(line)?;
+        if col == 0 {
+            return Some(0.into());
+        }
+
+        if self.is_line_only_ascii(line.try_into().unwrap()) {
+            let col = col.min(source_text.len());
+            Some(TextSize::from(col as u32))
+        } else {
+            let mut offset = 0;
+            let mut col = col;
+            for c in source_text[usize::from(start_offset)..].chars() {
+                if col == 0 {
+                    break;
+                }
+
+                offset += c.len_utf8();
+                col -= 1;
+            }
+            Some(TextSize::from(offset as u32))
+        }
+    }
 }