merge

Author: cscheid

Cargo.lock

@@ -23,6 +23,7 @@ anyhow = "1.0"
 regex = "1.10"
 colored = "2.1"
 quarto-markdown-pandoc.workspace = true
+quarto-error-reporting.workspace = true
 include_dir = "0.7"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"

crates/qmd-syntax-helper/Cargo.toml

@@ -1,37 +1,20 @@
 use anyhow::{Context, Result};
 use colored::Colorize;
-use serde::{Deserialize, Serialize};
 use std::fs;
 use std::path::Path;
 
 use crate::rule::{CheckResult, ConvertResult, Rule};
 use crate::utils::file_io::{read_file, write_file};
 
-#[derive(Debug, Serialize, Deserialize)]
-struct ErrorLocation {
-    row: usize,
-    column: usize,
-    byte_offset: usize,
-    size: usize,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct ParseError {
-    filename: String,
-    title: String,
-    message: String,
-    location: ErrorLocation,
-}
-
 pub struct DivWhitespaceConverter {}
 
 impl DivWhitespaceConverter {
     pub fn new() -> Result<Self> {
         Ok(Self {})
     }
 
-    /// Parse a file and get error locations as JSON
-    fn get_parse_errors(&self, file_path: &Path) -> Result<Vec<ParseError>> {
+    /// Parse a file and get diagnostic messages
+    fn get_parse_errors(&self, file_path: &Path) -> Result<Vec<quarto_error_reporting::DiagnosticMessage>> {
         let content = fs::read_to_string(file_path)
             .with_context(|| format!("Failed to read file: {}", file_path.display()))?;
 
@@ -48,31 +31,15 @@ impl DivWhitespaceConverter {
 
         match result {
             Ok(_) => Ok(Vec::new()), // No errors
-            Err(error_messages) => {
-                // Parse the JSON error output
-                // The error messages come as a single JSON array string
-                if error_messages.is_empty() {
-                    return Ok(Vec::new());
-                }
-
-                let json_str = error_messages.join("");
-
-                // Try to parse as JSON array
-                match serde_json::from_str::<Vec<ParseError>>(&json_str) {
-                    Ok(errors) => Ok(errors),
-                    Err(_) => {
-                        // If parsing fails, the messages are likely plain text warnings/debug messages
-                        // rather than actual syntax errors. These don't indicate div whitespace issues,
-                        // so we can safely ignore them for this specific rule.
-                        Ok(Vec::new())
-                    }
-                }
+            Err(diagnostics) => {
+                // Return diagnostic messages directly
+                Ok(diagnostics)
             }
         }
     }
 
     /// Find div fence errors that need whitespace fixes
-    fn find_div_whitespace_errors(&self, content: &str, errors: &[ParseError]) -> Vec<usize> {
+    fn find_div_whitespace_errors(&self, content: &str, errors: &[quarto_error_reporting::DiagnosticMessage]) -> Vec<usize> {
         let mut fix_positions = Vec::new();
         let lines: Vec<&str> = content.lines().collect();
 
@@ -85,12 +52,18 @@ impl DivWhitespaceConverter {
                 continue;
             }
 
+            // Extract row from location (if available)
+            // SourceInfo uses 0-indexed rows, div_whitespace uses them too
+            let error_row = error.location.as_ref()
+                .map(|loc| loc.range.start.row)
+                .unwrap_or(0);
+
             // The error might be on the line itself or the line before (for div fences)
             // Check both the current line and the previous line
-            let lines_to_check = if error.location.row > 0 {
-                vec![error.location.row - 1, error.location.row]
+            let lines_to_check = if error_row > 0 {
+                vec![error_row - 1, error_row]
             } else {
-                vec![error.location.row]
+                vec![error_row]
             };
 
             for &line_idx in &lines_to_check {