refactor: pass around &str instead of &[u8]

src/helpers/mod.rs

@@ -50,10 +50,14 @@ impl<'src> QueryHelper<'src> {
     ///
     /// Panics if Tree-sitter fails to parse the query.
     #[must_use]
-    pub fn new(query_src: &str, tree: &'src Tree, code: &'src [u8]) -> Self {
+    pub fn new(query_src: &str, tree: &'src Tree, code: &'src str) -> Self {
         let query =
             Query::new(&tree_sitter_c::LANGUAGE.into(), query_src).expect("Failed to parse query");
-        Self { query, tree, code }
+        Self {
+            query,
+            tree,
+            code: code.as_bytes(),
+        }
     }
 
     /// Returns a reference to this helper's query.
@@ -222,7 +226,7 @@ impl<'src> QueryHelper<'src> {
 /// - the node's text is not valid UTF-8
 ///
 #[must_use]
-pub fn function_definition_name<'code>(node: Node, code: &'code [u8]) -> &'code str {
+pub fn function_definition_name<'code>(node: Node, code: &'code str) -> &'code str {
     assert_eq!(
         "function_definition",
         node.kind(),
@@ -235,7 +239,7 @@ pub fn function_definition_name<'code>(node: Node, code: &'code [u8]) -> &'code
             .child_by_field_name("declarator")
             .expect("Expected node to have a `declarator' field");
     }
-    node.utf8_text(code).expect("Code is not valid UTF-8")
+    &code[node.byte_range()]
 }
 
 /// Gets the number of columns by which this line is indented. Tab characters (U+0009 or `'\t'`)
@@ -434,14 +438,10 @@ mod test {
             let mut parser = Parser::new();
             parser.set_language(&tree_sitter_c::LANGUAGE.into()).unwrap();
             let tree = parser.parse(code.as_bytes(), None).unwrap();
-            let helper =
-                QueryHelper::new("(function_definition) @function", &tree, code.as_bytes());
+            let helper = QueryHelper::new("(function_definition) @function", &tree, code);
             helper.for_each_capture(|label, capture| {
                 assert_eq!("function", label);
-                assert_eq!(
-                    expected_name,
-                    super::function_definition_name(capture.node, code.as_bytes())
-                );
+                assert_eq!(expected_name, super::function_definition_name(capture.node, code));
             });
         }
     }
@@ -478,7 +478,7 @@ mod test {
         let mut parser = Parser::new();
         parser.set_language(&tree_sitter_c::LANGUAGE.into()).unwrap();
         let tree = parser.parse(code.as_bytes(), None).unwrap();
-        let helper = QueryHelper::new("(preproc_def) @define", &tree, code.as_bytes());
+        let helper = QueryHelper::new("(preproc_def) @define", &tree, code);
         helper.for_each_capture(|_label, capture| ranges.push(capture.node.range()));
         let mut collapser = RangeCollapser::from(ranges.clone());
         let group1 = collapser.next().unwrap();

src/helpers/testing.rs

@@ -113,7 +113,7 @@ pub fn test_captures(query: &str, input: &str) -> ExitCode {
     let mut parser = Parser::new();
     parser.set_language(&tree_sitter_c::LANGUAGE.into()).unwrap();
     let tree = parser.parse(&code, None).unwrap();
-    let helper = QueryHelper::new(query, &tree, code.as_bytes());
+    let helper = QueryHelper::new(query, &tree, &code);
     let mut failed = false;
     helper.for_each_capture(|label, capture| {
         let start = capture.node.start_position();

src/main.rs

@@ -146,7 +146,7 @@ fn main() -> ExitCode {
     // Do checks
     let rules: Vec<Box<dyn Rule>> = crate::rules::get_rules();
     for rule in rules {
-        let diagnostics = rule.check(&tree, code.as_bytes());
+        let diagnostics = rule.check(&tree, &code);
         for diagnostic in diagnostics {
             match cli.format {
                 OutputFormat::Pretty => {

src/rules/api.rs

@@ -27,5 +27,5 @@ pub trait Rule {
     /// - `tree`: [`Tree`] representing the file.
     /// - `code`: Text/code of the given file.
     #[must_use]
-    fn check(&self, tree: &Tree, code: &[u8]) -> Vec<Diagnostic<()>>;
+    fn check(&self, tree: &Tree, code: &str) -> Vec<Diagnostic<()>>;
 }

src/rules/rule01a.rs

@@ -65,7 +65,7 @@ const QUERY_STR: &str = indoc! { /* query */ r#"
 pub struct Rule01a {}
 
 impl Rule for Rule01a {
-    fn check(&self, tree: &Tree, code: &[u8]) -> Vec<Diagnostic<()>> {
+    fn check(&self, tree: &Tree, code: &str) -> Vec<Diagnostic<()>> {
         let helper = QueryHelper::new(QUERY_STR, tree, code);
         let mut diagnostics = Vec::new();
         helper.for_each_capture(|_label, capture| {
@@ -86,9 +86,7 @@ impl Rule for Rule01a {
                 )
                 .with_label(Label::secondary((), capture.node.byte_range()).with_message(format!(
                     "Perhaps you meant `{}'",
-                    guess_lower_snake_case(
-                        capture.node.utf8_text(code).expect("Code is not valid UTF-8")
-                    )
+                    guess_lower_snake_case(&code[capture.node.byte_range()])
                 )));
             diagnostics.push(diagnostic);
         });

src/rules/rule01b.rs

@@ -46,7 +46,7 @@ use crate::rules::api::Rule;
 pub struct Rule01b {}
 
 impl Rule for Rule01b {
-    fn check(&self, _tree: &Tree, _code: &[u8]) -> Vec<Diagnostic<()>> {
+    fn check(&self, _tree: &Tree, _code: &str) -> Vec<Diagnostic<()>> {
         Vec::with_capacity(0)
     }
 }

src/rules/rule01c.rs

@@ -66,11 +66,11 @@ const QUERY_STR: &str = indoc! { /* query */ r#"
 pub struct Rule01c {}
 
 impl Rule for Rule01c {
-    fn check(&self, tree: &Tree, code: &[u8]) -> Vec<Diagnostic<()>> {
+    fn check(&self, tree: &Tree, code: &str) -> Vec<Diagnostic<()>> {
         let helper = QueryHelper::new(QUERY_STR, tree, code);
         let mut diagnostics = Vec::new();
         helper.for_each_capture(|name: &str, capture: QueryCapture| {
-            let node_text = capture.node.utf8_text(code).expect("Code is not valid UTF-8");
+            let node_text = &code[capture.node.byte_range()];
             let (message, label, fix) = match name {
                 "constant.name.short" => (
                     "Constant name must contain at least 2 characters",

src/rules/rule01d.rs

@@ -64,7 +64,7 @@ const QUERY_STR: &str = indoc! {
 pub struct Rule01d {}
 
 impl Rule for Rule01d {
-    fn check(&self, tree: &Tree, code: &[u8]) -> Vec<Diagnostic<()>> {
+    fn check(&self, tree: &Tree, code: &str) -> Vec<Diagnostic<()>> {
         let helper = QueryHelper::new(QUERY_STR, tree, code);
         let mut first_function_position = None;
         let mut diagnostics = Vec::new();
@@ -90,10 +90,7 @@ impl Rule for Rule01d {
                                 .with_message("Variable declared here"),
                         )
                         .with_label(Label::secondary((), capture.node.byte_range()).with_message(
-                            format!(
-                                "Perhaps you meant `g_{}'",
-                                capture.node.utf8_text(code).expect("Code is not valid UTF-8")
-                            ),
+                            format!("Perhaps you meant `g_{}'", &code[capture.node.byte_range()]),
                         ))
                 }
                 "declaration.top_level" => {

src/rules/rule02a.rs

@@ -106,11 +106,10 @@ const QUERY_STR: &str = indoc! { /* query */ r##"
 "## };
 
 impl Rule for Rule02a {
-    fn check(&self, tree: &Tree, code_bytes: &[u8]) -> Vec<Diagnostic<()>> {
+    fn check(&self, tree: &Tree, code: &str) -> Vec<Diagnostic<()>> {
         let mut diagnostics = Vec::new();
 
         // Check for lines >80 columns long
-        let code = std::str::from_utf8(code_bytes).expect("Code is not valid UTF-8");
         for (line, index) in LinesWithPosition::from(code) {
             let width = line_width(line);
             if width > 80 {
@@ -122,7 +121,7 @@ impl Rule for Rule02a {
             }
         }
 
-        let helper = QueryHelper::new(QUERY_STR, tree, code_bytes);
+        let helper = QueryHelper::new(QUERY_STR, tree, code);
         let splittable_capture_i = helper.expect_index_for_capture("splittable");
         let splittable_begin_capture_i = helper.expect_index_for_capture("splittable.begin");
         let splittable_end_capture_i = helper.expect_index_for_capture("splittable.end");
@@ -157,9 +156,7 @@ impl Rule for Rule02a {
             }
 
             // Check indentation of wrapped lines and construct list of labels
-            let mut code_lines = LinesWithPosition::from(
-                std::str::from_utf8(code_bytes).expect("Code is not valid UTF-8"),
-            )
+            let mut code_lines = LinesWithPosition::from(code)
             .skip(range.start_point.row)
             .take(range.end_point.row + 1 - range.start_point.row);
             let (first_line, first_line_byte_pos) = code_lines.next().unwrap();
@@ -337,7 +334,7 @@ mod tests {
                 code.push_str("}\n");
                 dbg!(&code);
                 let tree = parser.parse(code.as_bytes(), None).unwrap();
-                let diagnostics = rule.check(&tree, code.as_bytes());
+                let diagnostics = rule.check(&tree, &code);
                 assert_eq!($ndiag, diagnostics.len());
                 let nlabels_list: &[usize] = &$nlabels_list;
                 assert_eq!(

src/rules/rule02b.rs

@@ -53,7 +53,7 @@ const QUERY_STR: &str = indoc! {
 pub struct Rule02b {}
 
 impl Rule for Rule02b {
-    fn check(&self, tree: &Tree, code: &[u8]) -> Vec<Diagnostic<()>> {
+    fn check(&self, tree: &Tree, code: &str) -> Vec<Diagnostic<()>> {
         let helper = QueryHelper::new(QUERY_STR, tree, code);
         let mut diagnostics = Vec::new();
         helper.for_each_capture(|label: &str, capture: QueryCapture| match label {
@@ -110,7 +110,7 @@ mod tests {
         let tree = parser.parse(code.as_bytes(), None).unwrap();
         let rule02b = Rule02b {};
         assert_eq!(
-            rule02b.check(&tree, code.as_bytes()),
+            rule02b.check(&tree, &code),
             vec![Diagnostic::warning()
                 .with_code("II:B")
                 .with_message(format!(

src/rules/rule03a.rs

@@ -88,7 +88,7 @@ const QUERY_STR: &str = indoc! {
 pub struct Rule03a {}
 
 impl Rule for Rule03a {
-    fn check(&self, tree: &Tree, code: &[u8]) -> Vec<Diagnostic<()>> {
+    fn check(&self, tree: &Tree, code: &str) -> Vec<Diagnostic<()>> {
         let mut diagnostics = Vec::new();
 
         // Part 1: Space between parentheses and braces
@@ -119,10 +119,7 @@ impl Rule for Rule03a {
             // Check spacing between keyword and (
             let keyword = helper.expect_node_for_capture_index(qmatch, keyword_capture_i);
             let lparen = helper.expect_node_for_capture_index(qmatch, lparen_capture_i);
-            let message = format!(
-                "Expected a single space after `{}'",
-                keyword.utf8_text(code).expect("Code is not valid UTF-8")
-            );
+            let message = format!("Expected a single space after `{code}'");
             if let Some(diagnostic) = check_single_space_between(keyword, lparen, code, &message) {
                 diagnostics.push(diagnostic);
             }
@@ -137,13 +134,12 @@ impl Rule for Rule03a {
 fn check_single_space_between(
     left: Node,
     right: Node,
-    code: &[u8],
+    code: &str,
     message: &str,
 ) -> Option<Diagnostic<()>> {
     if (left.end_byte() + 1) == right.start_byte() {
         // One byte in between
-        // TODO: Support multi-byte UTF-8 characters here, not just bytes
-        if (code[left.end_byte()] as char) == ' ' {
+        if code.as_bytes()[left.end_byte()] == b' ' {
             // Valid
             return None;
         }

src/rules/rule03b.rs

@@ -95,7 +95,7 @@ const QUERY_STR_FIELD: &str = indoc! {
 pub struct Rule03b {}
 
 impl Rule for Rule03b {
-    fn check(&self, tree: &Tree, code: &[u8]) -> Vec<Diagnostic<()>> {
+    fn check(&self, tree: &Tree, code: &str) -> Vec<Diagnostic<()>> {
         let mut diagnostics = Vec::new();
 
         // Binary expressions
@@ -180,7 +180,7 @@ fn check_binary_op_spacing(
     op: Node,
     left: Node,
     right: Node,
-    code: &[u8],
+    code: &str,
 ) -> Option<Diagnostic<()>> {
     // If the adjacent items are on the same line, check that there's a single space between them.
     // If they're on separate lines, we do nothing, and leave it to Rule II:A to check the
@@ -243,9 +243,8 @@ fn check_field_op_spacing(op: Node, left: Node, right: Node) -> Option<Diagnosti
 }
 
 /// Returns `true` if there is a single space separating the two nodes, else `false`.
-fn is_single_space_between(left: Node, right: Node, code: &[u8]) -> bool {
-    // TODO: Support UTF-8, not just bytes
-    left.end_byte() + 1 == right.start_byte() && code[left.end_byte()] as char == ' '
+fn is_single_space_between(left: Node, right: Node, code: &str) -> bool {
+    left.end_byte() + 1 == right.start_byte() && code.as_bytes()[left.end_byte()] == b' '
 }
 
 #[cfg(test)]

src/rules/rule03c.rs

@@ -63,7 +63,7 @@ const QUERY_STR: &str = indoc! {
 pub struct Rule03c {}
 
 impl Rule for Rule03c {
-    fn check(&self, tree: &Tree, code: &[u8]) -> Vec<Diagnostic<()>> {
+    fn check(&self, tree: &Tree, code: &str) -> Vec<Diagnostic<()>> {
         let mut diagnostics = Vec::new();
         let helper = QueryHelper::new(QUERY_STR, tree, code);
         let delim_capture_i = helper.expect_index_for_capture("delim");
@@ -91,9 +91,9 @@ impl Rule for Rule03c {
 }
 
 /// Returns `true` if the two nodes are separated by a single space and `false` otherwise.
-fn is_single_space_between(left: Node, right: Node, code: &[u8]) -> bool {
+fn is_single_space_between(left: Node, right: Node, code: &str) -> bool {
     // TODO: Support UTF-8 and not just bytes
-    (left.end_byte() + 1) == right.start_byte() && (code[left.end_byte()] as char) == ' '
+    (left.end_byte() + 1) == right.start_byte() && code.as_bytes()[left.end_byte()] == b' '
 }
 
 #[cfg(test)]

src/rules/rule03d.rs

@@ -73,7 +73,7 @@ const QUERY_STR: &str = indoc! {
 pub struct Rule03d {}
 
 impl Rule for Rule03d {
-    fn check(&self, tree: &Tree, code: &[u8]) -> Vec<Diagnostic<()>> {
+    fn check(&self, tree: &Tree, code: &str) -> Vec<Diagnostic<()>> {
         // List of function definition bodies
         let mut function_bodies: Vec<Node> = Vec::new();
         // List of #define statements
@@ -150,9 +150,7 @@ impl Rule for Rule03d {
         }
 
         // Get lines of the source
-        let lines: Vec<(&str, usize)> =
-            LinesWithPosition::from(std::str::from_utf8(code).expect("Code is not valid UTF-8"))
-                .collect();
+        let lines: Vec<(&str, usize)> = LinesWithPosition::from(code).collect();
 
         // Collapse #define statements into groups
         let define_groups = RangeCollapser::from(definitions.into_iter().map(|def| def.range()));
@@ -290,8 +288,8 @@ impl Rule for Rule03d {
 
 /// Returns the byte range of a [Node], excluding the trailing end-of-line sequence if it was
 /// included in the node's range.
-fn range_without_trailing_eol(mut range: Range<usize>, code: &[u8]) -> Range<usize> {
-    match &code[(range.end - 2)..range.end] {
+fn range_without_trailing_eol(mut range: Range<usize>, code: &str) -> Range<usize> {
+    match &code.as_bytes()[(range.end - 2)..range.end] {
         [b'\r', b'\n'] => range.end -= 2,
         [_, b'\n'] => range.end -= 1,
         _ => (),
@@ -327,7 +325,7 @@ mod tests {
         parser.set_language(&tree_sitter_c::LANGUAGE.into()).unwrap();
         let tree = parser.parse(code.as_bytes(), None).unwrap();
         let rule = Rule03d {};
-        let diagnostics = rule.check(&tree, code.as_bytes());
+        let diagnostics = rule.check(&tree, code);
         // Expect 1 diagnostic for the whole group.
         assert_eq!(1, diagnostics.len());
     }
@@ -341,7 +339,7 @@ mod tests {
         parser.set_language(&tree_sitter_c::LANGUAGE.into()).unwrap();
         let tree = parser.parse(code.as_bytes(), None).unwrap();
         let rule = Rule03d {};
-        let diagnostics = rule.check(&tree, code.as_bytes());
+        let diagnostics = rule.check(&tree, code);
         assert_eq!(1, diagnostics.len());
         assert_eq!(code.lines().last().unwrap(), &code[diagnostics[0].labels[0].range.clone()]);
     }
@@ -355,7 +353,7 @@ mod tests {
         parser.set_language(&tree_sitter_c::LANGUAGE.into()).unwrap();
         let tree = parser.parse(code.as_bytes(), None).unwrap();
         let rule = Rule03d {};
-        let diagnostics = rule.check(&tree, code.as_bytes());
+        let diagnostics = rule.check(&tree, code);
         assert!(diagnostics.is_empty());
     }
 
@@ -368,7 +366,7 @@ mod tests {
         parser.set_language(&tree_sitter_c::LANGUAGE.into()).unwrap();
         let tree = parser.parse(code.as_bytes(), None).unwrap();
         let rule = Rule03d {};
-        let diagnostics = rule.check(&tree, code.as_bytes());
+        let diagnostics = rule.check(&tree, code);
         // Sanity checks
         assert_eq!(1, diagnostics.len());
         assert_eq!(LabelStyle::Primary, diagnostics[0].labels[0].style);

src/rules/rule03e.rs

@@ -29,10 +29,9 @@ use crate::{helpers::LinesWithPosition, rules::api::Rule};
 pub struct Rule03e {}
 
 impl Rule for Rule03e {
-    fn check(&self, _tree: &Tree, code: &[u8]) -> Vec<Diagnostic<()>> {
+    fn check(&self, _tree: &Tree, code: &str) -> Vec<Diagnostic<()>> {
         let mut diagnostics = Vec::new();
-        let code_str = std::str::from_utf8(code).expect("Code is not valid UTF-8");
-        for (line, index) in LinesWithPosition::from(code_str) {
+        for (line, index) in LinesWithPosition::from(code) {
             let trimmed_line = line.trim_end();
             if trimmed_line.len() != line.len() {
                 // Start/end of trailing whitespace
@@ -67,7 +66,7 @@ mod tests {
         parser.set_language(&tree_sitter_c::LANGUAGE.into()).unwrap();
         let tree = parser.parse(code, None).unwrap();
         let rule = Rule03e {};
-        let diagnostics = rule.check(&tree, code.as_bytes());
+        let diagnostics = rule.check(&tree, code);
         assert_eq!(2, diagnostics.len());
     }
 }

src/rules/rule03f.rs

@@ -47,7 +47,7 @@ const QUERY_STR: &str = indoc! {
 pub struct Rule03f {}
 
 impl Rule for Rule03f {
-    fn check(&self, tree: &Tree, code: &[u8]) -> Vec<Diagnostic<()>> {
+    fn check(&self, tree: &Tree, code: &str) -> Vec<Diagnostic<()>> {
         let mut diagnostics = Vec::new();
         let helper = QueryHelper::new(QUERY_STR, tree, code);
         let function_capture_i = helper.expect_index_for_capture("function");