[Lib] Fixed lint warnings

- Use slices instead of pointer arguments
- Replace len() > 0 with !is_empty()
- Swapped out expect(format!(...)) with unwrap_or_else(|| panic!(...))
- Remove self parameter and replace it with Self::find_fn_range(...)

Author: ttiimm

src/call_graph.rs

@@ -14,12 +14,12 @@ pub struct Edge<'a> {
 }
 
 impl<'a> CallGraph<'a> {
-    pub fn new(sources: &'a mut Vec<CodeSource>) -> CallGraph<'a> {
+    pub fn new(sources: &'a mut [CodeSource]) -> CallGraph<'a> {
         let edges = Self::find_edges(sources);
         CallGraph { edges }
     }
 
-    pub(crate) fn find_edges(sources: &'a mut Vec<CodeSource>) -> Vec<Edge<'a>> {
+    pub(crate) fn find_edges(sources: &'a mut [CodeSource]) -> Vec<Edge<'a>> {
         let mut symbols = Vec::new();
         let edge_query = r#"
             (call_expression function: (identifier) @fn_name arguments: (arguments (_))*)

src/lib.rs

@@ -129,7 +129,7 @@ pub fn extract_variables<'a>(
     src_ref: &'a SourceRef,
 ) -> HashMap<String, String> {
     let mut variables = HashMap::new();
-    if src_ref.vars.len() > 0 {
+    if !src_ref.vars.is_empty() {
         if let Some(captures) = src_ref.captures(&log_line) {
             for i in 0..captures.len() - 1 {
                 variables.insert(
@@ -238,7 +238,7 @@ pub fn find_possible_paths<'a>(
     possible
 }
 
-pub fn extract_logging<'a>(sources: &mut Vec<CodeSource>) -> Vec<SourceRef> {
+pub fn extract_logging(sources: &mut [CodeSource]) -> Vec<SourceRef> {
     let mut matched = Vec::new();
     for code in sources.iter_mut() {
         let src_query = SourceQuery::new(code);
@@ -326,7 +326,7 @@ fn nope(i: u32) {
     #[test]
     fn test_extract_logging() {
         let code = CodeSource::new(PathBuf::from("in-mem.rs"), Box::new(TEST_SOURCE.as_bytes()));
-        let src_refs = extract_logging(&mut vec![code]);
+        let src_refs = extract_logging(&mut [code]);
         assert_eq!(src_refs.len(), 2);
         let first = &src_refs[0];
         assert_eq!(first.line_no, 7);
@@ -349,7 +349,7 @@ fn nope(i: u32) {
             line: "[2024-02-15T03:46:44Z DEBUG stack] you're only as funky as your last cut",
         };
         let code = CodeSource::new(PathBuf::from("in-mem.rs"), Box::new(TEST_SOURCE.as_bytes()));
-        let src_refs = extract_logging(&mut vec![code]);
+        let src_refs = extract_logging(&mut [code]);
         assert_eq!(src_refs.len(), 2);
         let result = link_to_source(&log_ref, &src_refs);
         assert!(ptr::eq(result.unwrap(), &src_refs[0]));
@@ -362,10 +362,10 @@ fn nope(i: u32) {
         };
 
         let code = CodeSource::new(PathBuf::from("in-mem.rs"), Box::new(TEST_SOURCE.as_bytes()));
-        let src_refs = extract_logging(&mut vec![code]);
+        let src_refs = extract_logging(&mut [code]);
         assert_eq!(src_refs.len(), 2);
         let result = link_to_source(&log_ref, &src_refs);
-        assert_eq!(result.is_none(), true);
+        assert!(result.is_none());
     }
 
     #[test]
@@ -374,7 +374,7 @@ fn nope(i: u32) {
             line: "[2024-02-15T03:46:44Z DEBUG nope] this won't match i=1",
         };
         let code = CodeSource::new(PathBuf::from("in-mem.rs"), Box::new(TEST_SOURCE.as_bytes()));
-        let src_refs = extract_logging(&mut vec![code]);
+        let src_refs = extract_logging(&mut [code]);
         assert_eq!(src_refs.len(), 2);
         let vars = extract_variables(log_ref, &src_refs[1]);
         assert_eq!(vars.get("i").map(|val| val.as_str()), Some("1"));

src/log_format.rs

@@ -32,10 +32,9 @@ impl LogFormat {
     }
 
     pub fn captures<'a>(&self, log_ref: &LogRef<'a>) -> Captures<'a> {
-        self.regex.captures(log_ref.line).expect(&format!(
-            "Couldn't match `{}` with `{:?}`",
-            log_ref.line, self.regex
-        ))
+        self.regex
+            .captures(log_ref.line)
+            .unwrap_or_else(|| panic!("Couldn't match `{}` with `{:?}`", log_ref.line, self.regex))
     }
 }
 

src/source_query.rs

@@ -25,7 +25,7 @@ impl<'a> SourceQuery<'a> {
         let language = code.ts_language();
         parser
             .set_language(&language)
-            .expect(format!("Error loading {:?} grammar", language).as_str());
+            .unwrap_or_else(|_| panic!("Error loading {:?} grammar", language));
         let source = code.buffer.as_str();
         let tree = parser.parse(source, None).expect("source is parsable");
         // println!("{:?}", tree.root_node().to_sexp());
@@ -50,7 +50,7 @@ impl<'a> SourceQuery<'a> {
                     results.push(QueryResult {
                         kind: String::from(capture.node.kind()),
                         range: capture.node.range(),
-                        name_range: self.find_fn_range(capture.node),
+                        name_range: Self::find_fn_range(capture.node),
                     });
                 }
             }
@@ -59,7 +59,7 @@ impl<'a> SourceQuery<'a> {
         results
     }
 
-    fn find_fn_range(&self, node: Node) -> Range<usize> {
+    fn find_fn_range(node: Node) -> Range<usize> {
         // println!("node.kind()={:?}", node.kind());
         match node.kind() {
             "function_item" => {
@@ -79,7 +79,7 @@ impl<'a> SourceQuery<'a> {
                 range.start_byte..range.end_byte
             }
             _ => {
-                let r = self.find_fn_range(node.parent().unwrap());
+                let r = Self::find_fn_range(node.parent().unwrap());
                 // println!("*****");
                 r
             }