refactor(fieldmask): better path parser error

Author: FoyonaCZY

Cargo.lock

@@ -24,6 +24,7 @@ pilota-thrift-parser = { path = "../pilota-thrift-parser", version = "0.12" }
 pilota-thrift-reflect = { path = "../pilota-thrift-reflect", version = "0.1" }
 
 ahash.workspace = true
+ariadne.workspace = true
 faststr.workspace = true
 thiserror.workspace = true
 serde.workspace = true

pilota-thrift-fieldmask/Cargo.toml

@@ -1580,12 +1580,6 @@ mod tests {
 
     #[test]
     fn test_field_mask_error_display() {
-        let err = FieldMaskError::PathError {
-            path: FastStr::new("$.invalid"),
-            source: Box::new(PathError::SyntaxError { position: 5 }),
-        };
-        assert!(err.to_string().contains("path '$.invalid', parse error"));
-
         let err = FieldMaskError::TypeMismatch {
             detail: Box::new(TypeMismatchDetail {
                 expected: "Struct".into(),

pilota-thrift-fieldmask/src/fieldmask.rs

@@ -1,14 +1,15 @@
 use std::{fmt, str};
 
+use ariadne::{Color, Label, Report, ReportKind, Source};
 use chumsky::prelude::*;
 use pilota::FastStr;
 use pilota_thrift_parser::descriptor::Components;
 use thiserror::Error;
 
 #[derive(Debug, Clone, Error)]
 pub enum PathError {
-    #[error("syntax error at position {position}")]
-    SyntaxError { position: usize },
+    #[error("syntax error: {message}")]
+    SyntaxError { message: FastStr },
     #[error("unexpected EOF")]
     UnexpectedEof,
     #[error("path cannot be empty")]
@@ -219,9 +220,42 @@ impl PathIterator {
             .parse(src.as_ref())
             .into_output_errors();
         if !errs.is_empty() {
-            return Err(PathError::ParseError {
-                position: errs[0].span().start,
-                message: errs[0].to_string().into(),
+            let mut report_strings = Vec::with_capacity(errs.len() + 1);
+
+            let title = format!("{} errors found: ", errs.len());
+            report_strings.push(title);
+            report_strings.push(String::new());
+
+            for (i, e) in errs.iter().enumerate() {
+                if errs.len() > 1 {
+                    let error_header = format!("Error {}:", i + 1);
+                    report_strings.push(error_header.clone());
+                }
+
+                let mut buffer = Vec::new();
+                Report::build(ReportKind::Error, e.span().into_range())
+                    .with_config(ariadne::Config::new().with_index_type(ariadne::IndexType::Byte))
+                    .with_message(e.to_string())
+                    .with_label(
+                        Label::new(e.span().into_range())
+                            .with_message(e.reason().to_string())
+                            .with_color(Color::Red),
+                    )
+                    .finish()
+                    .write(Source::from(src.as_ref()), &mut buffer)
+                    .unwrap();
+                report_strings.push(String::from_utf8_lossy(&buffer).to_string());
+
+                if i < errs.len() - 1 {
+                    report_strings.push(String::new());
+                }
+            }
+
+            let report = report_strings.join("\n");
+            let summary = create_error_summary(&errs, src.as_ref());
+
+            return Err(PathError::SyntaxError {
+                message: format!("summary: {}, report: {}", summary, report).into(),
             });
         }
 
@@ -247,6 +281,54 @@ impl PathIterator {
     }
 }
 
+fn create_error_summary(errs: &[chumsky::error::Rich<char>], text: &str) -> String {
+    if errs.is_empty() {
+        return String::new();
+    }
+
+    let mut summary = String::new();
+
+    if errs.len() == 1 {
+        let err = &errs[0];
+        // 计算行号和列号
+        let (line, col) = calculate_line_col(err.span().start, text);
+        summary.push_str(&format!(" at line {}:{} - {}", line, col, err.reason()));
+    } else {
+        summary.push_str(&format!(" ({} errors found):", errs.len()));
+        for (i, err) in errs.iter().enumerate() {
+            let (line, col) = calculate_line_col(err.span().start, text);
+            summary.push_str(&format!(
+                "\n  {}. Line {}:{} - {}",
+                i + 1,
+                line,
+                col,
+                err.reason()
+            ));
+        }
+    }
+
+    summary
+}
+
+fn calculate_line_col(pos: usize, text: &str) -> (usize, usize) {
+    let mut line = 1;
+    let mut col = 1;
+
+    for (i, ch) in text.char_indices() {
+        if i >= pos {
+            break;
+        }
+        if ch == '\n' {
+            line += 1;
+            col = 1;
+        } else {
+            col += 1;
+        }
+    }
+
+    (line, col)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;