wrap QueryError fields with getters (#1434)

OmarTawfik · web-flow · commit ba4fc11af8e4 · 2025-10-01T11:27:51.000Z
diff --git a/crates/metaslang/cst/generated/public_api.txt b/crates/metaslang/cst/generated/public_api.txt
diff --git a/crates/metaslang/cst/src/query/model.rs b/crates/metaslang/cst/src/query/model.rs
@@ -36,10 +36,10 @@ impl<T: KindTypes> Query<T> {
                 ASTNode::Capture(capture) => {
                     // If the capture has already been used, return an error
                     if capture_quantifiers.contains_key(&capture.name) {
-                        return Err(QueryError {
-                            message: format!("Capture name '{}' used more than once", capture.name),
-                            text_range: TextIndex::ZERO..TextIndex::ZERO,
-                        });
+                        return Err(QueryError::create(
+                            format!("Capture name '{}' used more than once", capture.name),
+                            TextIndex::ZERO..TextIndex::ZERO,
+                        ));
                     }
                     capture_quantifiers.insert(capture.name.clone(), quantifier);
                     collect_capture_quantifiers(&capture.child, quantifier, capture_quantifiers)?;
@@ -79,11 +79,10 @@ impl<T: KindTypes> Query<T> {
                         CaptureQuantifier::One => CaptureQuantifier::OneOrMore,
                         CaptureQuantifier::ZeroOrOne => CaptureQuantifier::ZeroOrMore,
                         CaptureQuantifier::OneOrMore | CaptureQuantifier::ZeroOrMore => {
-                            return Err(QueryError {
-                                message: "Quantification over quantification is not allowed"
-                                    .to_string(),
-                                text_range: TextIndex::ZERO..TextIndex::ZERO,
-                            })
+                            return Err(QueryError::create(
+                                "Quantification over quantification is not allowed".to_string(),
+                                TextIndex::ZERO..TextIndex::ZERO,
+                            ))
                         }
                     };
                     collect_capture_quantifiers(
diff --git a/crates/metaslang/cst/src/query/parser.rs b/crates/metaslang/cst/src/query/parser.rs
@@ -26,10 +26,28 @@ use crate::text_index::{TextIndex, TextRange};
 /// Error from parsing a query.
 #[derive(Clone, Debug, Error)]
 pub struct QueryError {
+    message: String,
+    text_range: TextRange,
+}
+
+impl QueryError {
     /// The error message describing the parsing issue.
-    pub message: String,
+    pub fn message(&self) -> &str {
+        &self.message
+    }
+
     /// The range of text where the error occurred.
-    pub text_range: TextRange,
+    pub fn text_range(&self) -> &TextRange {
+        &self.text_range
+    }
+
+    /// Creates a new `QueryError` with the given message and text range.
+    pub fn create(message: String, text_range: TextRange) -> Self {
+        QueryError {
+            message,
+            text_range,
+        }
+    }
 }
 
 impl std::fmt::Display for QueryError {
diff --git a/crates/metaslang/graph_builder/src/parser.rs b/crates/metaslang/graph_builder/src/parser.rs
@@ -48,7 +48,7 @@ pub enum ParseError {
     InvalidRegex(String, Location),
     #[error("Expected integer constant in regex capture at {0}")]
     InvalidRegexCapture(Location),
-    #[error("Invalid query pattern: {}", _0.message)]
+    #[error("Invalid query pattern: {}", _0.message())]
     QueryError(#[from] QueryError),
     #[error("Unexpected character '{0}' in {1} at {2}")]
     UnexpectedCharacter(char, &'static str, Location),
@@ -94,8 +94,8 @@ impl std::fmt::Display for DisplayParseErrorPretty<'_> {
             ParseError::InvalidRegex(_, location) => *location,
             ParseError::InvalidRegexCapture(location) => *location,
             ParseError::QueryError(err) => Location {
-                row: err.text_range.start.line,
-                column: err.text_range.start.column,
+                row: err.text_range().start.line,
+                column: err.text_range().start.column,
             },
             ParseError::UnexpectedCharacter(_, _, location) => *location,
             ParseError::UnexpectedEOF(location) => *location,
@@ -371,21 +371,18 @@ impl<'a> Parser<'a> {
 
         let query_source = &self.source[query_start..query_end];
 
-        let query = Query::create(query_source).map_err(|mut e| {
-            let start_offset = query_start + e.text_range.start.utf8;
-            let end_offset = query_start + e.text_range.end.utf8;
+        let query = Query::create(query_source).map_err(|e| {
+            let message = e.message().to_string();
+            let start_offset = query_start + e.text_range().start.utf8;
+            let end_offset = query_start + e.text_range().end.utf8;
 
-            e.text_range.start = TextIndex::ZERO;
-            e.text_range
-                .start
-                .advance_str(&self.source[0..start_offset]);
+            let mut start_index = TextIndex::ZERO;
+            start_index.advance_str(&self.source[0..start_offset]);
 
-            e.text_range.end = e.text_range.start;
-            e.text_range
-                .end
-                .advance_str(&self.source[start_offset..end_offset]);
+            let mut end_index = start_index.clone();
+            end_index.advance_str(&self.source[start_offset..end_offset]);
 
-            e
+            QueryError::create(message, start_index..end_index)
         })?;
 
         Ok(query)
diff --git a/crates/metaslang/graph_builder/tests/parser.rs b/crates/metaslang/graph_builder/tests/parser.rs
@@ -1585,9 +1585,9 @@ fn query_parse_errors_have_file_location() {
         Err(ParseError::QueryError(e)) => e,
         Err(e) => panic!("Unexpected error: {e}"),
     };
-    assert_eq!(err.message, "Parse error:\n'NonExistingNode' is not a valid node kind at: NonExistingNode ] ]\n        \n");
+    assert_eq!(err.message(), "Parse error:\n'NonExistingNode' is not a valid node kind at: NonExistingNode ] ]\n        \n");
     assert_eq!(
-        format!("{:?}", err.text_range),
+        format!("{:?}", err.text_range()),
         "TextIndex { utf8: 50, utf16: 50, line: 2, column: 19 }..TextIndex { utf8: 78, utf16: 78, line: 3, column: 8 }",
     );
 }
@@ -1608,9 +1608,9 @@ fn multiline_query_parse_errors_have_file_location() {
         Err(ParseError::QueryError(e)) => e,
         Err(e) => panic!("Unexpected error: {e}"),
     };
-    assert_eq!(err.message, "Parse error:\n'NonExistingNode' is not a valid node kind at: NonExistingNode ] ]\n        )\n        \n");
+    assert_eq!(err.message(), "Parse error:\n'NonExistingNode' is not a valid node kind at: NonExistingNode ] ]\n        )\n        \n");
     assert_eq!(
-        format!("{:?}", err.text_range),
+        format!("{:?}", err.text_range()),
         "TextIndex { utf8: 112, utf16: 112, line: 5, column: 23 }..TextIndex { utf8: 150, utf16: 150, line: 7, column: 8 }",
     );
 }
diff --git a/crates/solidity/outputs/cargo/tests/src/cst/queries/parser_tests.rs b/crates/solidity/outputs/cargo/tests/src/cst/queries/parser_tests.rs
@@ -53,9 +53,9 @@ fn test_parsing_error() {
     match result {
         Ok(_) => panic!("Expected error"),
         Err(e) => {
-            assert_eq!(e.message, "Parse error:\nexpected ']' at: \nAlt at: [_\n");
+            assert_eq!(e.message(), "Parse error:\nexpected ']' at: \nAlt at: [_\n");
             assert_eq!(
-                format!("{:?}", e.text_range),
+                format!("{:?}", e.text_range()),
                 "TextIndex { utf8: 8, utf16: 8, line: 0, column: 8 }..TextIndex { utf8: 8, utf16: 8, line: 0, column: 8 }",
             );
         }
@@ -70,11 +70,11 @@ fn test_parsing_error_with_invalid_edge_label() {
         Ok(_) => panic!("Expected error"),
         Err(e) => {
             assert_eq!(
-                e.message,
+                e.message(),
                 "Parse error:\n'Name' is not a valid edge label at: Name: [_]]\n",
             );
             assert_eq!(
-                format!("{:?}", e.text_range),
+                format!("{:?}", e.text_range()),
                 "TextIndex { utf8: 18, utf16: 18, line: 0, column: 18 }..TextIndex { utf8: 28, utf16: 28, line: 0, column: 28 }",
             );
         }
@@ -88,11 +88,11 @@ fn test_parsing_error_with_invalid_node_kind() {
         Ok(_) => panic!("Expected error"),
         Err(e) => {
             assert_eq!(
-                e.message,
+                e.message(),
                 "Parse error:\n'tree_node' is not a valid node kind at: tree_node]]\n",
             );
             assert_eq!(
-                format!("{:?}", e.text_range),
+                format!("{:?}", e.text_range()),
                 "TextIndex { utf8: 13, utf16: 13, line: 0, column: 13 }..TextIndex { utf8: 24, utf16: 24, line: 0, column: 24 }",
             );
         }
@@ -106,11 +106,11 @@ fn test_parsing_error_with_kind_beginning_with_underscore() {
         Ok(_) => panic!("Expected error"),
         Err(e) => {
             assert_eq!(
-                e.message,
+                e.message(),
                 "Parse error:\n'_tree_node' is not a valid node kind at: _tree_node]]\n",
             );
             assert_eq!(
-                format!("{:?}", e.text_range),
+                format!("{:?}", e.text_range()),
                 "TextIndex { utf8: 13, utf16: 13, line: 0, column: 13 }..TextIndex { utf8: 25, utf16: 25, line: 0, column: 25 }",
             );
         }
@@ -123,7 +123,7 @@ fn test_fails_parsing_ellipsis() {
     match result {
         Ok(_) => panic!("Expected parse failure"),
         Err(e) => assert_eq!(
-            e.message,
+            e.message(),
             "Parse error:\nThe ellipsis `...` operator is deprecated, and replaced with a new adjacency `.` operator. at: ...]\n",
         ),
     }
@@ -134,7 +134,7 @@ fn test_fails_consecutive_adjacency_operators() {
     let result = Query::create(r#"[_ [Identifier] . .]"#);
     match result {
         Ok(_) => panic!("Expected parse failure"),
-        Err(e) => assert_eq!(e.message, "Parse error:\nNoneOf at: .]\n"),
+        Err(e) => assert_eq!(e.message(), "Parse error:\nNoneOf at: .]\n"),
     }
 }
 
@@ -144,7 +144,7 @@ fn test_fails_sole_adjacency() {
     match result {
         Ok(_) => panic!("Expected parse failure"),
         Err(e) => assert_eq!(
-            e.message,
+            e.message(),
             "Parse error:\nexpected ']' at: .]\nAlt at: [_ .]\n"
         ),
     }
@@ -162,7 +162,7 @@ fn test_fails_parsing_trivia_node_selector() {
     match result {
         Ok(_) => panic!("Expected parse failure"),
         Err(e) => assert_eq!(
-            e.message,
+            e.message(),
             "Parse error:\nMatching trivia nodes directly is forbidden. at: EndOfLine]\n"
         ),
     }
diff --git a/crates/solidity/outputs/cargo/wasm/src/wasm_crate/wrappers/cst/mod.rs b/crates/solidity/outputs/cargo/wasm/src/wasm_crate/wrappers/cst/mod.rs
@@ -403,8 +403,8 @@ impl IntoFFI<ffi::QueryError> for rust::QueryError {
     #[inline]
     fn _into_ffi(self) -> ffi::QueryError {
         ffi::QueryError {
-            message: self.message,
-            text_range: self.text_range._into_ffi(),
+            message: self.message().to_string(),
+            text_range: self.text_range()._into_ffi(),
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -403,8 +403,8 @@ impl IntoFFI<ffi::QueryError> for rust::QueryError {`
`403`	`403`	`#[inline]`
`404`	`404`	`fn _into_ffi(self) -> ffi::QueryError {`
`405`	`405`	`ffi::QueryError {`
`406`		`- message: self.message,`
`407`		`- text_range: self.text_range._into_ffi(),`
	`406`	`+ message: self.message().to_string(),`
	`407`	`+ text_range: self.text_range()._into_ffi(),`
`408`	`408`	`}`
`409`	`409`	`}`
`410`	`410`	`}`