[function-grep]

working to remove panicking code (specifically in language instantiation
plus a bit of cleanup

Author: mendelsshop

function-grep/examples/main.rs

@@ -3,12 +3,11 @@
 #![deny(missing_debug_implementations, clippy::missing_panics_doc)]
 #![warn(clippy::pedantic, clippy::nursery, clippy::cargo)]
 #![deny(clippy::use_self, rust_2018_idioms)]
-use function_grep::supported_languages::InstantiateMap;
+use function_grep::supported_languages::{InstantiateMap, InstantiationError};
 use function_grep::{supported_languages::predefined_languages, ParsedFile};
 
 use clap::Parser;
 use std::{fs::File, io::Read, path::PathBuf};
-use tree_sitter::QueryError;
 #[derive(Parser, Debug)]
 #[command(version, about)]
 pub struct Args {
@@ -23,7 +22,7 @@ pub enum Error {
     CouldNotOpenFile(std::io::Error),
     CouldNotReadFile(std::io::Error),
     LibraryError(function_grep::Error),
-    QueryError(QueryError),
+    InstatantiationError(InstantiationError),
 }
 
 ///
@@ -38,7 +37,7 @@ pub fn main() -> Result<(), Error> {
     let mut code = String::new();
     let languages = predefined_languages()
         .instantiate_map(&args.name)
-        .map_err(Error::QueryError)?;
+        .map_err(Error::InstatantiationError)?;
     file.read_to_string(&mut code)
         .map_err(Error::CouldNotReadFile)?;
     let file_name = &args.file.to_string_lossy();

function-grep/src/filter.rs

@@ -117,7 +117,6 @@ pub trait HasFilterInformation {
     fn supports(&self) -> Self::Supports;
 
     fn attributes(&self) -> Attributes;
-    // TODO: have filter creation informaton about types and fields for uis
     fn filter_info(&self) -> FilterInformation<Self::Supports> {
         FilterInformation {
             filter_name: self.filter_name(),

function-grep/src/filter/filter_parsers.rs

@@ -37,5 +37,9 @@ pub fn string<'a>(
     position: &str,
     filter: &str,
 ) -> Result<String, String> {
-    substring.next().map(ToOwned::to_owned).ok_or_else(||format! ("invalid options for function_with_parameter filter\nexpected {format}\n missing {position} [number]"))
+    substring.next().map(ToOwned::to_owned).ok_or_else(|| {
+        format!(
+            "invalid options for {filter} filter\nexpected {format}\n missing {position} [string]"
+        )
+    })
 }

function-grep/src/filter/general_filters.rs

@@ -171,7 +171,7 @@ impl Filter for FunctionWithParameterRust {
             cursor.matches(&query, *node, text_provider).any(|c| {
                 c.captures
                     .iter()
-                    .any(|c| c.node.utf8_text(text_provider).unwrap() == name)
+                    .any(|c| c.node.utf8_text(text_provider).unwrap_or("") == name)
             })
         }))
     }
@@ -198,7 +198,7 @@ impl HasFilterInformation for FunctionWithParameterPython {
 }
 
 impl Filter for FunctionWithParameterPython {
-    fn parse_filter(&self, s: &str) -> Result<FilterFunction, String> {
+    fn parse_filter(&self, _s: &str) -> Result<FilterFunction, String> {
         todo!()
     }
 }

function-grep/src/supported_languages.rs

@@ -14,6 +14,12 @@ pub struct InstantiatedLanguage<'a> {
     run_query: QueryFunction,
 }
 
+#[derive(Debug)]
+pub enum InstantiationError {
+    NoMatchingField(String),
+    Query(QueryError),
+    Tags(tree_sitter_tags::Error),
+}
 pub trait HasLanguageInformation {
     /// The name of this language
     fn language_name(&self) -> &'static str;
@@ -88,49 +94,59 @@ pub struct TreeSitter;
 pub struct Tags;
 // TODO: hide in docs?
 trait InstantiateHelper<Type> {
-    fn instantiate(&self, search: Box<str>) -> QueryFunction;
+    fn instantiate(&self, search: Box<str>) -> Result<QueryFunction, InstantiationError>;
 }
 
 // TODO: hide in docs?
 pub trait Assoc {
     type Type;
 }
 impl<T: IdentifierQuery> InstantiateHelper<Identifier> for T {
-    fn instantiate(&self, search: Box<str>) -> QueryFunction {
-        let query = Query::new(&self.language(), &self.query_string().to_string()).unwrap();
-        let method_field = query
-            .capture_index_for_name(&self.query_name().to_string())
-            .unwrap();
-        Box::new(move |node, code| {
-            let name = &*search;
-            let mut query_cursor = tree_sitter::QueryCursor::new();
-            let matches = query_cursor.matches(&query, node, code);
-            let ranges = matches
-                .filter(move |m| {
-                    m.captures
-                        .iter()
-                        .any(|c| c.index == method_field && c.node.utf8_text(code).unwrap() == name)
-                })
-                .map(|m| m.captures[0].node.range());
-
-            ranges.collect()
-        })
+    fn instantiate(&self, search: Box<str>) -> Result<QueryFunction, InstantiationError> {
+        Query::new(&self.language(), &self.query_string().to_string())
+            .map_err(InstantiationError::Query)
+            .and_then(|query: Query| {
+                query
+                    .capture_index_for_name(&self.query_name().to_string())
+                    .ok_or_else(|| {
+                        InstantiationError::NoMatchingField(self.query_name().to_string())
+                    })
+                    .map(|method_field| -> QueryFunction {
+                        Box::new(move |node, code| {
+                            let name = &*search;
+                            let mut query_cursor = tree_sitter::QueryCursor::new();
+                            let matches = query_cursor.matches(&query, node, code);
+                            let ranges = matches
+                                .filter(move |m| {
+                                    m.captures.iter().any(|c| {
+                                        c.index == method_field
+                                            && c.node.utf8_text(code).unwrap_or("") == name
+                                    })
+                                })
+                                .map(|m| m.captures[0].node.range());
+
+                            ranges.collect()
+                        })
+                    })
+            })
     }
 }
 impl<T: TreeSitterQuery> InstantiateHelper<TreeSitter> for T {
-    fn instantiate(&self, search: Box<str>) -> QueryFunction {
-        let query = Query::new(
+    fn instantiate(&self, search: Box<str>) -> Result<QueryFunction, InstantiationError> {
+        Query::new(
             &self.language(),
             &self.query_string_function(search.as_ref()),
         )
-        .unwrap();
-        Box::new(move |node, code| {
-            let mut query_cursor = tree_sitter::QueryCursor::new();
-            let matches = query_cursor.matches(&query, node, code);
-
-            let ranges = matches.map(|m| m.captures[0].node.range());
-            ranges.collect()
+        .map(|query| -> QueryFunction {
+            Box::new(move |node, code| {
+                let mut query_cursor = tree_sitter::QueryCursor::new();
+                let matches = query_cursor.matches(&query, node, code);
+
+                let ranges = matches.map(|m| m.captures[0].node.range());
+                ranges.collect()
+            })
         })
+        .map_err(InstantiationError::Query)
     }
 }
 struct TagsConfigurationThreadSafe(TagsConfiguration);
@@ -156,64 +172,75 @@ impl TagsConfigurationThreadSafe {
     }
 }
 impl<T: TreeSitterTags> InstantiateHelper<Tags> for T {
-    fn instantiate(&self, search: Box<str>) -> QueryFunction {
-        let tag_config = TagsConfigurationThreadSafe(
-            TagsConfiguration::new(self.language(), &self.tag_query().to_string(), "").unwrap(),
-        );
-        Box::new(move |node, code| {
-            let mut tag_context = TagsContext::new();
-            let name = &*search;
-            // TODO: don't double parse
-            let tags = tag_config
-                .generate_tags(&mut tag_context, code, None)
-                .unwrap()
-                .0;
-            let ranges = tags
-                .filter_map(Result::ok)
-                .filter(|tag| {
-                    ["method", "function"]
-                        .contains(&tag_config.syntax_type_name(tag.syntax_type_id))
-                        && str::from_utf8(&code[tag.name_range.clone()]).unwrap_or("") == name
+    fn instantiate(&self, search: Box<str>) -> Result<QueryFunction, InstantiationError> {
+        TagsConfiguration::new(self.language(), &self.tag_query().to_string(), "")
+            .map_err(InstantiationError::Tags)
+            .map(|tag_config| -> QueryFunction {
+                let tag_config = TagsConfigurationThreadSafe(tag_config);
+                Box::new(move |node, code| {
+                    let mut tag_context = TagsContext::new();
+                    let name = &*search;
+                    // TODO: don't double parse
+                    tag_config
+                        .generate_tags(&mut tag_context, code, None)
+                        .map(|tags| {
+                            let ranges = tags
+                                .0
+                                .filter_map(Result::ok)
+                                .filter(|tag| {
+                                    ["method", "function"]
+                                        .contains(&tag_config.syntax_type_name(tag.syntax_type_id))
+                                        && str::from_utf8(&code[tag.name_range.clone()])
+                                            .unwrap_or("")
+                                            == name
+                                })
+                                .filter_map(|tag| {
+                                    node.descendant_for_byte_range(tag.range.start, tag.range.end)
+                                        .map(|node| node.range())
+                                });
+                            ranges.collect()
+                        })
+                        .unwrap_or_else(|_| vec![].into_boxed_slice())
                 })
-                .filter_map(|tag| {
-                    node.descendant_for_byte_range(tag.range.start, tag.range.end)
-                        .map(|node| node.range())
-                });
-            ranges.collect()
-        })
+            })
     }
 }
+
 impl<T: Assoc + InstantiateHelper<T::Type> + HasLanguageInformation> SupportedLanguage for T {
-    fn instantiate(&self, search: Box<str>) -> QueryFunction {
+    fn instantiate(&self, search: Box<str>) -> Result<QueryFunction, InstantiationError> {
         self.instantiate(search)
     }
 }
+// TODO: maybe make this fallable
 type QueryFunction = Box<dyn for<'x, 'y> Fn(Node<'x>, &'y [u8]) -> Box<[Range]> + Send + Sync>;
 
 pub trait SupportedLanguage: HasLanguageInformation {
-    fn instantiate(&self, search: Box<str>) -> QueryFunction;
-    fn to_language<'a>(&self, search: &'a str) -> InstantiatedLanguage<'a> {
-        InstantiatedLanguage::new(
-            search,
-            self.language_info(),
-            self.instantiate(search.into()),
-        )
+    fn instantiate(&self, search: Box<str>) -> Result<QueryFunction, InstantiationError>;
+    fn to_language<'a>(
+        &self,
+        search: &'a str,
+    ) -> Result<InstantiatedLanguage<'a>, InstantiationError> {
+        self.instantiate(search.into())
+            .map(|f| InstantiatedLanguage::new(search, self.language_info(), f))
     }
 }
 
 pub trait InstantiateMap<'a> {
-    fn instantiate_map(self, name: &'a str) -> Result<Vec<InstantiatedLanguage<'a>>, QueryError>;
+    fn instantiate_map(
+        self,
+        name: &'a str,
+    ) -> Result<Vec<InstantiatedLanguage<'a>>, InstantiationError>;
 }
 impl<'a, T, U> InstantiateMap<'a> for T
 where
     T: IntoIterator<Item = U>,
     U: Deref<Target = &'a dyn SupportedLanguage>,
 {
-    fn instantiate_map(self, name: &'a str) -> Result<Vec<InstantiatedLanguage<'a>>, QueryError> {
-        Ok(self
-            .into_iter()
-            .map(|l| InstantiatedLanguage::new(name, l.language_info(), l.instantiate(name.into())))
-            .collect())
+    fn instantiate_map(
+        self,
+        name: &'a str,
+    ) -> Result<Vec<InstantiatedLanguage<'a>>, InstantiationError> {
+        self.into_iter().map(|l| l.to_language(name)).collect()
     }
 }
 impl<'a> InstantiatedLanguage<'a> {