refactor: construct reusable source code information only once (#21)

Closes #11.

Author: kdkasad

src/main.rs

@@ -34,6 +34,7 @@ use codespan_reporting::{
     },
 };
 use crashlog::cargo_metadata;
+use rules::api::SourceInfo;
 use tree_sitter::{Parser, Tree};
 
 pub mod helpers;
@@ -145,8 +146,9 @@ fn main() -> ExitCode {
 
     // Do checks
     let rules: Vec<Box<dyn Rule>> = crate::rules::get_rules();
+    let source = SourceInfo::new(&code);
     for rule in rules {
-        let diagnostics = rule.check(&tree, &code);
+        let diagnostics = rule.check(&source);
         for diagnostic in diagnostics {
             match cli.format {
                 OutputFormat::Pretty => {

src/rules/api.rs

@@ -17,6 +17,26 @@
 use codespan_reporting::diagnostic::Diagnostic;
 use tree_sitter::Tree;
 
+use crate::helpers::LinesWithPosition;
+
+pub struct SourceInfo<'src> {
+    pub tree: Tree,
+    pub code: &'src str,
+    pub lines: Box<[(&'src str, usize)]>,
+}
+
+impl<'src> SourceInfo<'src> {
+    pub fn new(code: &'src str) -> Self {
+        let mut parser = tree_sitter::Parser::new();
+        parser
+            .set_language(&tree_sitter_c::LANGUAGE.into())
+            .expect("Failed to set language");
+        let tree = parser.parse(code, None).expect("Failed to parse code");
+        let lines = LinesWithPosition::from(code).collect();
+        Self { tree, code, lines }
+    }
+}
+
 /// Represents a linter rule.
 pub trait Rule {
     /// Checks a source file for compliance with this rule.
@@ -27,5 +47,5 @@ pub trait Rule {
     /// - `tree`: [`Tree`] representing the file.
     /// - `code`: Text/code of the given file.
     #[must_use]
-    fn check(&self, tree: &Tree, code: &str) -> Vec<Diagnostic<()>>;
+    fn check(&self, source: &SourceInfo) -> Vec<Diagnostic<()>>;
 }

src/rules/rule01a.rs

@@ -32,10 +32,11 @@
 
 use codespan_reporting::diagnostic::{Diagnostic, Label};
 use indoc::indoc;
-use tree_sitter::Tree;
 
 use crate::{helpers::QueryHelper, rules::api::Rule};
 
+use crate::rules::api::SourceInfo;
+
 const QUERY_STR: &str = indoc! { /* query */ r#"
     (
         [
@@ -65,7 +66,7 @@ const QUERY_STR: &str = indoc! { /* query */ r#"
 pub struct Rule01a {}
 
 impl Rule for Rule01a {
-    fn check(&self, tree: &Tree, code: &str) -> Vec<Diagnostic<()>> {
+    fn check(&self, SourceInfo { tree, code, .. }: &SourceInfo) -> Vec<Diagnostic<()>> {
         let helper = QueryHelper::new(QUERY_STR, tree, code);
         let mut diagnostics = Vec::new();
         helper.for_each_capture(|_label, capture| {

src/rules/rule01b.rs

@@ -36,17 +36,16 @@
 //! - Make this rule produce a table of all declared identifiers at the end of parsing.
 
 use codespan_reporting::diagnostic::Diagnostic;
-use tree_sitter::Tree;
 
-use crate::rules::api::Rule;
+use crate::rules::api::{Rule, SourceInfo};
 
 /// # Rule I:B.
 ///
 /// See module-level documentation for details.
 pub struct Rule01b {}
 
 impl Rule for Rule01b {
-    fn check(&self, _tree: &Tree, _code: &str) -> Vec<Diagnostic<()>> {
+    fn check(&self, _: &SourceInfo) -> Vec<Diagnostic<()>> {
         Vec::with_capacity(0)
     }
 }

src/rules/rule01c.rs

@@ -40,10 +40,12 @@
 
 use codespan_reporting::diagnostic::{Diagnostic, Label};
 use indoc::indoc;
-use tree_sitter::{QueryCapture, Tree};
+use tree_sitter::QueryCapture;
 
 use crate::{helpers::QueryHelper, rules::api::Rule};
 
+use crate::rules::api::SourceInfo;
+
 /// Tree-sitter query for Rule I:C.
 const QUERY_STR: &str = indoc! { /* query */ r#"
     (
@@ -66,7 +68,7 @@ const QUERY_STR: &str = indoc! { /* query */ r#"
 pub struct Rule01c {}
 
 impl Rule for Rule01c {
-    fn check(&self, tree: &Tree, code: &str) -> Vec<Diagnostic<()>> {
+    fn check(&self, SourceInfo { tree, code, .. }: &SourceInfo) -> Vec<Diagnostic<()>> {
         let helper = QueryHelper::new(QUERY_STR, tree, code);
         let mut diagnostics = Vec::new();
         helper.for_each_capture(|name: &str, capture: QueryCapture| {

src/rules/rule01d.rs

@@ -32,9 +32,12 @@
 
 use codespan_reporting::diagnostic::{Diagnostic, Label};
 use indoc::indoc;
-use tree_sitter::{QueryCapture, Tree};
+use tree_sitter::QueryCapture;
 
-use crate::{helpers::QueryHelper, rules::api::Rule};
+use crate::{
+    helpers::QueryHelper,
+    rules::api::{Rule, SourceInfo},
+};
 
 /// Tree-sitter query for Rule I:D.
 const QUERY_STR: &str = indoc! {
@@ -64,7 +67,7 @@ const QUERY_STR: &str = indoc! {
 pub struct Rule01d {}
 
 impl Rule for Rule01d {
-    fn check(&self, tree: &Tree, code: &str) -> Vec<Diagnostic<()>> {
+    fn check(&self, SourceInfo { tree, code, .. }: &SourceInfo) -> Vec<Diagnostic<()>> {
         let helper = QueryHelper::new(QUERY_STR, tree, code);
         let mut first_function_position = None;
         let mut diagnostics = Vec::new();

src/rules/rule02a.rs

@@ -35,13 +35,12 @@
 
 use codespan_reporting::diagnostic::{Diagnostic, Label};
 use indoc::indoc;
-use tree_sitter::{Range, Tree};
+use tree_sitter::Range;
 use unicode_width::UnicodeWidthStr;
 
-use crate::{
-    helpers::{LinesWithPosition, QueryHelper},
-    rules::api::Rule,
-};
+use crate::{helpers::QueryHelper, rules::api::Rule};
+
+use crate::rules::api::SourceInfo;
 
 /// Amount that wrapped lines must be indented, in columns.
 const WRAPPED_LINE_INDENT_WIDTH: usize = 2;
@@ -106,11 +105,11 @@ const QUERY_STR: &str = indoc! { /* query */ r##"
 "## };
 
 impl Rule for Rule02a {
-    fn check(&self, tree: &Tree, code: &str) -> Vec<Diagnostic<()>> {
+    fn check(&self, SourceInfo { tree, code, lines }: &SourceInfo) -> Vec<Diagnostic<()>> {
         let mut diagnostics = Vec::new();
 
         // Check for lines >80 columns long
-        for (line, index) in LinesWithPosition::from(code) {
+        for (line, index) in lines {
             let width = line_width(line);
             if width > 80 {
                 let diagnostic = Diagnostic::warning()
@@ -156,15 +155,15 @@ impl Rule for Rule02a {
             }
 
             // Check indentation of wrapped lines and construct list of labels
-            let mut code_lines = LinesWithPosition::from(code)
+            let mut code_lines = lines.iter()
             .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();
+            let &(first_line, first_line_byte_pos) = code_lines.next().unwrap();
             let first_line_indent = get_indentation(first_line);
             let first_line_indent_width = line_width(first_line_indent);
             let expected_indent_width = first_line_indent_width + WRAPPED_LINE_INDENT_WIDTH;
             let mut labels = Vec::new();
-            for (this_line, this_line_pos) in &mut code_lines {
+            for &(this_line, this_line_pos) in &mut code_lines {
                 let this_line_indent = get_indentation(this_line);
                 let this_line_indent_width = line_width(this_line_indent);
                 if this_line_indent_width < expected_indent_width {
@@ -224,9 +223,11 @@ mod tests {
 
     use indoc::indoc;
     use pretty_assertions::assert_eq;
-    use tree_sitter::Parser;
 
-    use crate::{helpers::testing::test_captures, rules::api::Rule};
+    use crate::{
+        helpers::testing::test_captures,
+        rules::api::{Rule, SourceInfo},
+    };
 
     use super::{Rule02a, QUERY_STR};
 
@@ -318,8 +319,6 @@ mod tests {
     #[test]
     fn test_rule02a_diagnostics() {
         let rule = Rule02a {};
-        let mut parser = Parser::new();
-        parser.set_language(&tree_sitter_c::LANGUAGE.into()).unwrap();
 
         macro_rules! test {
             ($code:literal, $ndiag:expr, $nlabels_list:expr) => {
@@ -333,8 +332,8 @@ mod tests {
                 }
                 code.push_str("}\n");
                 dbg!(&code);
-                let tree = parser.parse(code.as_bytes(), None).unwrap();
-                let diagnostics = rule.check(&tree, &code);
+                let source = SourceInfo::new(&code);
+                let diagnostics = rule.check(&source);
                 assert_eq!($ndiag, diagnostics.len());
                 let nlabels_list: &[usize] = &$nlabels_list;
                 assert_eq!(

src/rules/rule02b.rs

@@ -27,13 +27,15 @@
 
 use codespan_reporting::diagnostic::{Diagnostic, Label};
 use indoc::indoc;
-use tree_sitter::{QueryCapture, Tree};
+use tree_sitter::QueryCapture;
 
 use crate::{
     helpers::{function_definition_name, QueryHelper},
     rules::api::Rule,
 };
 
+use crate::rules::api::SourceInfo;
+
 /// Number of lines per page
 const PAGE_SIZE: usize = 61;
 /// Maximum number of pages a function definition may span
@@ -53,7 +55,7 @@ const QUERY_STR: &str = indoc! {
 pub struct Rule02b {}
 
 impl Rule for Rule02b {
-    fn check(&self, tree: &Tree, code: &str) -> Vec<Diagnostic<()>> {
+    fn check(&self, SourceInfo { tree, code, .. }: &SourceInfo) -> 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 {
@@ -86,11 +88,10 @@ impl Rule for Rule02b {
 
 #[cfg(test)]
 mod tests {
-    use crate::rules::api::Rule;
+    use crate::rules::api::{Rule, SourceInfo};
 
     use codespan_reporting::diagnostic::{Diagnostic, Label};
     use pretty_assertions::assert_eq;
-    use tree_sitter::Parser;
 
     use super::{Rule02b, MAX_PAGES_PER_FUNCTION, PAGE_SIZE};
 
@@ -105,12 +106,10 @@ mod tests {
         code.push_str("}\n");
 
         // Test for diagnostic
-        let mut parser = Parser::new();
-        parser.set_language(&tree_sitter_c::LANGUAGE.into()).unwrap();
-        let tree = parser.parse(code.as_bytes(), None).unwrap();
         let rule02b = Rule02b {};
+        let source = SourceInfo::new(&code);
         assert_eq!(
-            rule02b.check(&tree, &code),
+            rule02b.check(&source),
             vec![Diagnostic::warning()
                 .with_code("II:B")
                 .with_message(format!(

src/rules/rule03a.rs

@@ -26,10 +26,12 @@
 
 use codespan_reporting::diagnostic::{Diagnostic, Label};
 use indoc::indoc;
-use tree_sitter::{Node, Tree};
+use tree_sitter::Node;
 
 use crate::{helpers::QueryHelper, rules::api::Rule};
 
+use crate::rules::api::SourceInfo;
+
 /// Tree-sitter query for Rule III:A.
 const QUERY_STR: &str = indoc! {
     /* query */
@@ -88,7 +90,7 @@ const QUERY_STR: &str = indoc! {
 pub struct Rule03a {}
 
 impl Rule for Rule03a {
-    fn check(&self, tree: &Tree, code: &str) -> Vec<Diagnostic<()>> {
+    fn check(&self, SourceInfo { tree, code, .. }: &SourceInfo) -> Vec<Diagnostic<()>> {
         let mut diagnostics = Vec::new();
 
         // Part 1: Space between parentheses and braces
@@ -119,7 +121,8 @@ 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 `{code}'");
+            let message =
+                format!("Expected a single space after `{}'", &code[keyword.byte_range()]);
             if let Some(diagnostic) = check_single_space_between(keyword, lparen, code, &message) {
                 diagnostics.push(diagnostic);
             }

src/rules/rule03b.rs

@@ -32,10 +32,12 @@
 
 use codespan_reporting::diagnostic::{Diagnostic, Label};
 use indoc::indoc;
-use tree_sitter::{Node, Tree};
+use tree_sitter::Node;
 
 use crate::{helpers::QueryHelper, rules::api::Rule};
 
+use crate::rules::api::SourceInfo;
+
 /// Tree-sitter query to capture binary expressions/operators.
 const QUERY_STR_BINARY: &str = indoc! {
     /* query */
@@ -95,7 +97,7 @@ const QUERY_STR_FIELD: &str = indoc! {
 pub struct Rule03b {}
 
 impl Rule for Rule03b {
-    fn check(&self, tree: &Tree, code: &str) -> Vec<Diagnostic<()>> {
+    fn check(&self, SourceInfo { tree, code, .. }: &SourceInfo) -> Vec<Diagnostic<()>> {
         let mut diagnostics = Vec::new();
 
         // Binary expressions