Crate-level API changes for tree-sitter-lint

Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "tree-sitter-grep"
+name = "tree_sitter_lint_tree-sitter-grep"
 version = "0.1.0"
 edition = "2021"
 license = "Unlicense OR MIT"
@@ -8,6 +8,7 @@ authors = [
   "Peter Stuart <peter@peterstuart.org>"
 ]
 description = """
+(not-yet-landed version used by tree-sitter-lint)
 tree-sitter-grep is a grep-like search tool that
 recursively searches the current directory for a
 tree-sitter query pattern. Like ripgrep, it respects
@@ -25,6 +26,7 @@ rust-version = "1.70"
 bstr = "1.1.0"
 bytecount = "0.6"
 clap = { version = "4.3.0", features = ["derive", "wrap_help"] }
+derive_builder = "0.12.0"
 encoding_rs = "0.8.14"
 encoding_rs_io = "0.1.6"
 ignore = { package = "tree_sitter_grep_ignore", git = "https://github.com/helixbass/ripgrep", rev = "669ebd3", version = "0.4.20-dev.0" }
@@ -34,10 +36,13 @@ log = "0.4.5"
 memchr = "2.1"
 memmap = { package = "memmap2", version = "0.5.3" }
 once_cell = "1.18.0"
+ouroboros = "0.17.2"
 proc_macros = { package = "tree_sitter_grep_proc_macros", path = "proc_macros", version = "0.1.0" }
 rayon = "1.7.0"
 regex = "1.8.2"
+ropey = "1.6.0"
 serde = { version = "1.0.77", features = ["derive"] }
+streaming-iterator = "0.1.9"
 strum_macros = "0.25.1"
 termcolor = "1.2.0"
 thiserror = "1.0.43"
@@ -65,6 +70,9 @@ tree-sitter-swift = "0.3.6"
 tree-sitter-toml = "0.20.0"
 tree-sitter-typescript = "0.20.2"
 
+[patch.crates-io]
+tree-sitter = { git = "https://github.com/helixbass/tree-sitter", rev = "57e98fb0" }
+
 [[bin]]
 name = "tree-sitter-grep"
 

examples/filter_before_line_number.rs

@@ -5,7 +5,7 @@ use std::{
 
 use libc::c_char;
 use tree_sitter::Node;
-use tree_sitter_grep::PluginInitializeReturn;
+use tree_sitter_lint_tree_sitter_grep::PluginInitializeReturn;
 
 static ROW_NUMBER: AtomicUsize = AtomicUsize::new(0);
 

examples/print_match_text.rs

@@ -1,12 +1,12 @@
 use clap::Parser;
-use tree_sitter_grep::{run_with_callback, Args};
+use tree_sitter_lint_tree_sitter_grep::{run_with_callback, Args};
 
 fn main() {
     let args = Args::parse_from(["tree_sitter_grep", "-q", "(function_item) @f"]);
-    run_with_callback(args, |node, file_contents, path| {
+    run_with_callback(args, |capture_info, file_contents, path| {
         println!(
             "Found match in {path:?}: {}",
-            std::str::from_utf8(&file_contents[node.byte_range()]).unwrap(),
+            std::str::from_utf8(&file_contents[capture_info.node.byte_range()]).unwrap(),
         );
     })
     .unwrap();

proc_macros/src/lib.rs

@@ -133,7 +133,7 @@ fn get_token_enum_definition(
     variants_with_attributes: &[ExprPath],
 ) -> proc_macro2::TokenStream {
     quote! {
-        #[derive(Copy, Clone, Debug, Eq, PartialEq, clap::ValueEnum, strum_macros::Display)]
+        #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, clap::ValueEnum, strum_macros::Display)]
         pub enum #name {
             #(#variants_with_attributes),*
         }

rustfmt.toml

@@ -3,4 +3,5 @@ format_macro_bodies = true
 format_macro_matchers = true
 group_imports = "StdExternalCrate"
 imports_granularity = "Crate"
-wrap_comments = true
+edition = "2021"
+# wrap_comments = true

src/args.rs

@@ -1,13 +1,16 @@
 use std::{
+    collections::HashMap,
     fs,
     path::{Path, PathBuf},
     sync::{Arc, Mutex},
 };
 
 use clap::{ArgGroup, Parser};
+use derive_builder::Builder;
 use ignore::{types::Types, WalkBuilder, WalkParallel};
 use rayon::iter::IterBridge;
 use termcolor::BufferWriter;
+use tree_sitter::Query;
 
 use crate::{
     language::SupportedLanguage,
@@ -23,7 +26,8 @@ use crate::{
 
 const ALL_NODES_QUERY: &str = "(_) @node";
 
-#[derive(Parser)]
+#[derive(Builder, Clone, Default, Parser)]
+#[builder(default, setter(strip_option, into))]
 #[clap(group(
     ArgGroup::new("query_or_filter")
         .multiple(true)
@@ -37,13 +41,16 @@ pub struct Args {
     ///
     /// This conflicts with the --query option.
     #[arg(short = 'Q', long = "query-file", conflicts_with = "query_text")]
-    pub path_to_query_file: Option<PathBuf>,
+    path_to_query_file: Option<PathBuf>,
 
     /// The source text of a tree-sitter query.
     ///
     /// This conflicts with the --query-file option.
     #[arg(short, long = "query", conflicts_with = "path_to_query_file")]
-    pub query_text: Option<String>,
+    query_text: Option<String>,
+
+    #[clap(skip)]
+    query_per_language: Option<HashMap<SupportedLanguage, Arc<Query>>>,
 
     /// The name of the tree-sitter query capture (without leading "@") whose
     /// matching nodes will be output.
@@ -174,7 +181,11 @@ impl Args {
     }
 
     pub(crate) fn get_project_file_walker_types(&self) -> Types {
-        get_project_file_walker_types(self.language)
+        get_project_file_walker_types(self.language.map(|language| vec![language]).or_else(|| {
+            self.query_per_language
+                .as_ref()
+                .map(|query_per_language| query_per_language.keys().cloned().collect())
+        }))
     }
 
     pub(crate) fn get_project_file_walker(&self) -> WalkParallel {
@@ -199,18 +210,81 @@ impl Args {
         Ok(get_loaded_filter(self.filter.as_deref(), self.filter_arg.as_deref())?.map(Arc::new))
     }
 
-    pub(crate) fn get_loaded_query_text(&self) -> Result<String, Error> {
+    pub(crate) fn get_loaded_query_text_per_language(
+        &self,
+    ) -> Result<QueryOrQueryTextPerLanguage, Error> {
         Ok(
-            match (self.path_to_query_file.as_ref(), self.query_text.as_ref()) {
-                (Some(path_to_query_file), None) => fs::read_to_string(path_to_query_file)
+            match (
+                self.path_to_query_file.as_ref(),
+                self.query_text.as_ref(),
+                self.query_per_language.as_ref(),
+            ) {
+                (Some(path_to_query_file), None, None) => fs::read_to_string(path_to_query_file)
                     .map_err(|source| Error::QueryFileReadError {
                         source,
                         path_to_query_file: path_to_query_file.clone(),
-                    })?,
-                (None, Some(query_text)) => query_text.clone(),
-                (None, None) => ALL_NODES_QUERY.to_owned(),
+                    })?
+                    .into(),
+                (None, Some(query_text), None) => query_text.clone().into(),
+                (None, None, Some(query_per_language)) => query_per_language.clone().into(),
+                (None, None, None) => ALL_NODES_QUERY.to_owned().into(),
                 _ => unreachable!(),
             },
         )
     }
 }
+
+impl ArgsBuilder {
+    pub fn maybe_language(&mut self, language: Option<SupportedLanguage>) -> &mut Self {
+        self.language = Some(language);
+        self
+    }
+}
+
+pub enum QueryOrQueryTextPerLanguage {
+    SingleQueryText(String),
+    PerLanguage(HashMap<SupportedLanguage, Arc<Query>>),
+}
+
+impl QueryOrQueryTextPerLanguage {
+    pub fn get_query_or_query_text_for_language(
+        &self,
+        language: SupportedLanguage,
+    ) -> QueryOrQueryText {
+        match self {
+            QueryOrQueryTextPerLanguage::SingleQueryText(query_text) => (&**query_text).into(),
+            QueryOrQueryTextPerLanguage::PerLanguage(per_language) => {
+                per_language.get(&language).unwrap().clone().into()
+            }
+        }
+    }
+}
+
+impl From<String> for QueryOrQueryTextPerLanguage {
+    fn from(value: String) -> Self {
+        Self::SingleQueryText(value)
+    }
+}
+
+impl From<HashMap<SupportedLanguage, Arc<Query>>> for QueryOrQueryTextPerLanguage {
+    fn from(value: HashMap<SupportedLanguage, Arc<Query>>) -> Self {
+        Self::PerLanguage(value)
+    }
+}
+
+pub enum QueryOrQueryText<'a> {
+    QueryText(&'a str),
+    Query(Arc<Query>),
+}
+
+impl<'a> From<&'a str> for QueryOrQueryText<'a> {
+    fn from(value: &'a str) -> Self {
+        Self::QueryText(value)
+    }
+}
+
+impl<'a> From<Arc<Query>> for QueryOrQueryText<'a> {
+    fn from(value: Arc<Query>) -> Self {
+        Self::Query(value)
+    }
+}

src/bin/tree-sitter-grep.rs

@@ -1,7 +1,7 @@
 use std::process;
 
 use clap::Parser;
-use tree_sitter_grep::{run_print, Args, RunStatus};
+use tree_sitter_lint_tree_sitter_grep::{run_print, Args, RunStatus};
 
 pub fn main() {
     let args = Args::parse();