bindings: Require range and match limit in InactiveQueryCursor::new

Because of the way that cursors are cached, we need to set or reset
the byte range and match limit when re-using from the cache. In most
cases callers should set a byte range and match limit, so rather than
resetting these we require them in `new`.

Author: the-mikedavis

bindings/src/query_cursor.rs

@@ -133,14 +133,18 @@ pub struct InactiveQueryCursor {
 }
 
 impl InactiveQueryCursor {
-    pub fn new() -> Self {
-        unsafe {
+    #[must_use]
+    pub fn new(range: Range<u32>, limit: u32) -> Self {
+        let mut this = unsafe {
             with_cache(|cache| {
                 cache.pop().unwrap_or_else(|| InactiveQueryCursor {
                     ptr: NonNull::new_unchecked(ts_query_cursor_new()),
                 })
             })
-        }
+        };
+        this.set_byte_range(range);
+        this.set_match_limit(limit);
+        this
     }
 
     /// Return the maximum number of in-progress matches for this cursor.
@@ -193,7 +197,7 @@ impl InactiveQueryCursor {
 
 impl Default for InactiveQueryCursor {
     fn default() -> Self {
-        Self::new()
+        Self::new(0..u32::MAX, u32::MAX)
     }
 }
 

highlighter/src/injections_query.rs

@@ -290,10 +290,8 @@ impl InjectionsQuery {
         source: RopeSlice<'a>,
         loader: &'a impl LanguageLoader,
     ) -> impl Iterator<Item = InjectionQueryMatch<'a>> + 'a {
-        let mut cursor = InactiveQueryCursor::new();
-        cursor.set_byte_range(0..u32::MAX);
-        cursor.set_match_limit(TREE_SITTER_MATCH_LIMIT);
-        let mut cursor = cursor.execute_query(&self.injection_query, node, source);
+        let mut cursor = InactiveQueryCursor::new(0..u32::MAX, TREE_SITTER_MATCH_LIMIT)
+            .execute_query(&self.injection_query, node, source);
         let injection_content_capture = self.injection_content_capture.unwrap();
         let iter = iter::from_fn(move || loop {
             let (query_match, node_idx) = cursor.next_matched_node()?;

highlighter/src/locals.rs

@@ -189,10 +189,8 @@ impl Syntax {
         }
 
         let root = layer_data.parse_tree.as_ref().unwrap().root_node();
-        let mut cursor = InactiveQueryCursor::new();
-        cursor.set_byte_range(0..u32::MAX);
-        cursor.set_match_limit(TREE_SITTER_MATCH_LIMIT);
-        let mut cursor = cursor.execute_query(&injection_query.local_query, &root, source);
+        let mut cursor = InactiveQueryCursor::new(0..u32::MAX, TREE_SITTER_MATCH_LIMIT)
+            .execute_query(&injection_query.local_query, &root, source);
         let mut locals = Locals::default();
         let mut scope = Scope::ROOT;
 

highlighter/src/query_iter.rs

@@ -120,10 +120,8 @@ where
                         .get_query(layer.language)
                         .and_then(|query| Some((query, layer.tree()?.root_node())))
                         .map(|(query, node)| {
-                            let mut cursor = InactiveQueryCursor::new();
-                            cursor.set_match_limit(TREE_SITTER_MATCH_LIMIT);
-                            cursor.set_byte_range(self.range.clone());
-                            cursor.execute_query(query, &node, RopeInput::new(self.src))
+                            InactiveQueryCursor::new(self.range.clone(), TREE_SITTER_MATCH_LIMIT)
+                                .execute_query(query, &node, RopeInput::new(self.src))
                         })
                 };
                 Box::new(ActiveLayer {