Take references in from_query() and supply static queries

Author: lionel-

crates/ark/src/lsp/indexer.rs

@@ -19,6 +19,7 @@ use stdext::unwrap;
 use stdext::unwrap::IntoResult;
 use tower_lsp::lsp_types::Range;
 use tree_sitter::Node;
+use tree_sitter::Query;
 use walkdir::DirEntry;
 use walkdir::WalkDir;
 
@@ -347,23 +348,27 @@ fn index_r6_class_methods(
     entries: &mut Vec<IndexEntry>,
 ) -> anyhow::Result<()> {
     // Tree-sitter query to match individual methods in R6Class public/private lists
-    let query_str = r#"
-    (argument
-      name: (identifier) @access
-      value: (call
-        function: (identifier) @_list_fn
-        arguments: (arguments
-          (argument
-            name: (identifier) @method_name
-            value: (function_definition) @method_fn
-          )
-        )
-      )
-      (#match? @access "public|private")
-      (#eq? @_list_fn "list")
-    )
-    "#;
-    let mut ts_query = TsQuery::new(query_str)?;
+    static R6_METHODS_QUERY: LazyLock<Query> = LazyLock::new(|| {
+        let query_str = r#"
+            (argument
+                name: (identifier) @access
+                value: (call
+                    function: (identifier) @_list_fn
+                    arguments: (arguments
+                        (argument
+                            name: (identifier) @method_name
+                            value: (function_definition) @method_fn
+                        )
+                    )
+                )
+                (#match? @access "public|private")
+                (#eq? @_list_fn "list")
+            )
+        "#;
+        let language = &tree_sitter_r::LANGUAGE.into();
+        Query::new(language, query_str).expect("Failed to compile R6 methods query")
+    });
+    let mut ts_query = TsQuery::from_query(&*R6_METHODS_QUERY);
 
     // We'll switch from Rope to String in the near future so let's not
     // worry about this conversion now

crates/ark/src/lsp/inputs/package_namespace.rs

@@ -4,7 +4,10 @@
 // Copyright (C) 2025 by Posit Software, PBC
 //
 
+use std::sync::LazyLock;
+
 use tree_sitter::Parser;
+use tree_sitter::Query;
 
 use crate::treesitter::TsQuery;
 
@@ -32,24 +35,29 @@ impl Namespace {
             .ok_or_else(|| anyhow::anyhow!("Failed to parse NAMESPACE file"))?;
         let root_node = tree.root_node();
 
-        let query_str = r#"
-            (call
-                function: (identifier) @fn_name
-                arguments: (arguments (argument value: (identifier) @exported))
-                (#eq? @fn_name "export")
-            )
-            (call
-                function: (identifier) @fn_name
-                arguments: (arguments (argument value: (identifier) @pkg) (argument value: (identifier) @imported))
-                (#eq? @fn_name "importFrom")
-            )
-            (call
-                function: (identifier) @fn_name
-                arguments: (arguments (argument value: (identifier) @imported_pkgs))
-                (#eq? @fn_name "import")
-            )
-        "#;
-        let mut ts_query = TsQuery::new(query_str)?;
+        static NAMESPACE_QUERY: LazyLock<Query> = LazyLock::new(|| {
+            let query_str = r#"
+                (call
+                    function: (identifier) @fn_name
+                    arguments: (arguments (argument value: (identifier) @exported))
+                    (#eq? @fn_name "export")
+                )
+                (call
+                    function: (identifier) @fn_name
+                    arguments: (arguments (argument value: (identifier) @pkg) (argument value: (identifier) @imported))
+                    (#eq? @fn_name "importFrom")
+                )
+                (call
+                    function: (identifier) @fn_name
+                    arguments: (arguments (argument value: (identifier) @imported_pkgs))
+                    (#eq? @fn_name "import")
+                )
+            "#;
+            let language = &tree_sitter_r::LANGUAGE.into();
+            tree_sitter::Query::new(language, query_str).expect("Failed to compile NAMESPACE query")
+        });
+
+        let mut ts_query = TsQuery::from_query(&*NAMESPACE_QUERY);
 
         let captures = ts_query.captures_by(
             root_node,

crates/ark/src/treesitter.rs

@@ -642,23 +642,35 @@ pub(crate) fn point_end_of_previous_row(
     }
 }
 
-pub(crate) struct TsQuery {
-    query: tree_sitter::Query,
+pub(crate) struct TsQuery<'ts_query> {
+    query: QueryStorage<'ts_query>,
     cursor: tree_sitter::QueryCursor,
 }
 
-impl TsQuery {
+pub(crate) enum QueryStorage<'ts_query> {
+    Owned(tree_sitter::Query),
+    Borrowed(&'ts_query tree_sitter::Query),
+}
+
+impl<'ts_query> TsQuery<'ts_query> {
+    #[allow(unused)]
     pub(crate) fn new(query_str: &str) -> anyhow::Result<Self> {
         let language = &tree_sitter_r::LANGUAGE.into();
         let query = tree_sitter::Query::new(language, query_str)
             .map_err(|err| anyhow!("Failed to compile query: {err}"))?;
 
-        Ok(Self::from_query(query))
+        Ok(Self {
+            query: QueryStorage::Owned(query),
+            cursor: tree_sitter::QueryCursor::new(),
+        })
     }
 
-    pub(crate) fn from_query(query: tree_sitter::Query) -> Self {
+    pub(crate) fn from_query(query: &'ts_query tree_sitter::Query) -> Self {
         let cursor = tree_sitter::QueryCursor::new();
-        Self { query, cursor }
+        Self {
+            query: QueryStorage::Borrowed(query),
+            cursor,
+        }
     }
 
     /// Run the query on `contents` and collect all captures as (capture_name, node) pairs
@@ -670,8 +682,12 @@ impl TsQuery {
     where
         'tree: 'query,
     {
-        let matches_iter = self.cursor.matches(&self.query, node, contents);
-        AllCaptures::new(&self.query, matches_iter)
+        let query = match self.query {
+            QueryStorage::Owned(ref q) => q,
+            QueryStorage::Borrowed(q) => q,
+        };
+        let matches_iter = self.cursor.matches(query, node, contents);
+        AllCaptures::new(query, matches_iter)
     }
 
     /// Run the query on `contents` and filter captures that match `capture_name`