Associate capture functions with the relevant types

src/execution.rs

···
 
 use thiserror::Error;
 use tree_sitter::CaptureQuantifier;
+use tree_sitter::Node;
 use tree_sitter::QueryMatch;
 use tree_sitter::Tree;
 
···
 #[error("Cancelled at \"{0}\"")]
 pub struct CancellationError(pub &'static str);
 
-/// Get the value for the given capture, considering the suffix
-pub(self) fn query_capture_value<'tree>(
-    index: usize,
-    quantifier: CaptureQuantifier,
-    mat: &QueryMatch<'_, 'tree>,
-    graph: &mut Graph<'tree>,
-) -> Value {
-    let mut nodes = mat
-        .captures
-        .iter()
-        .filter(|c| c.index as usize == index)
-        .map(|c| c.node);
-    match quantifier {
-        CaptureQuantifier::Zero => unreachable!(),
-        CaptureQuantifier::One => {
-            let syntax_node = graph.add_syntax_node(nodes.next().expect("missing capture"));
-            syntax_node.into()
-        }
-        CaptureQuantifier::ZeroOrMore | CaptureQuantifier::OneOrMore => {
-            let syntax_nodes = nodes
-                .map(|n| graph.add_syntax_node(n.clone()).into())
-                .collect::<Vec<Value>>();
-            syntax_nodes.into()
-        }
-        CaptureQuantifier::ZeroOrOne => match nodes.next() {
-            None => Value::Null.into(),
-            Some(node) => {
-                let syntax_node = graph.add_syntax_node(node);
+impl crate::ast::Stanza {
+    /// Return the top-level matched node from a file query match result.
+    pub fn full_capture_from_file_match<'a, 'cursor: 'a, 'tree: 'a>(
+        &self,
+        mat: &'a QueryMatch<'cursor, 'tree>,
+    ) -> impl Iterator<Item = Node<'tree>> + 'a {
+        mat.nodes_for_capture_index(self.full_match_file_capture_index as u32)
+    }
+
+    /// Return the top-level matched node from a stanza query match result.
+    pub fn full_capture_from_stanza_match<'a, 'cursor: 'a, 'tree: 'a>(
+        &self,
+        mat: &'a QueryMatch<'cursor, 'tree>,
+    ) -> impl Iterator<Item = Node<'tree>> + 'a {
+        mat.nodes_for_capture_index(self.full_match_stanza_capture_index as u32)
+    }
+}
+
+impl Value {
+    pub fn from_nodes<'tree, NI: IntoIterator<Item = Node<'tree>>>(
+        graph: &mut Graph<'tree>,
+        nodes: NI,
+        quantifier: CaptureQuantifier,
+    ) -> Value {
+        let mut nodes = nodes.into_iter();
+        match quantifier {
+            CaptureQuantifier::Zero => unreachable!(),
+            CaptureQuantifier::One => {
+                let syntax_node = graph.add_syntax_node(nodes.next().expect("missing capture"));
                 syntax_node.into()
             }
-        },
+            CaptureQuantifier::ZeroOrMore | CaptureQuantifier::OneOrMore => {
+                let syntax_nodes = nodes
+                    .map(|n| graph.add_syntax_node(n.clone()).into())
+                    .collect::<Vec<Value>>();
+                syntax_nodes.into()
+            }
+            CaptureQuantifier::ZeroOrOne => match nodes.next() {
+                None => Value::Null.into(),
+                Some(node) => {
+                    let syntax_node = graph.add_syntax_node(node);
+                    syntax_node.into()
+                }
+            },
+        }
     }
 }

src/execution/lazy.rs

···
 use crate::execution::error::ExecutionError;
 use crate::execution::error::ResultWithExecutionError;
 use crate::execution::error::StatementContext;
-use crate::execution::query_capture_value;
 use crate::execution::ExecutionConfig;
 use crate::functions::Functions;
 use crate::graph;
 use crate::graph::Graph;
+use crate::graph::Value;
 use crate::variables::Globals;
 use crate::variables::MutVariables;
 use crate::variables::VariableMap;
···
     ) -> Result<(), ExecutionError> {
         let current_regex_captures = vec![];
         locals.clear();
-        let node = query_capture_value(self.full_match_file_capture_index, One, &mat, graph);
+        let node = Value::from_nodes(graph, self.full_capture_from_file_match(mat), One);
         debug!("match {} at {}", node, self.location);
         trace!("{{");
         for statement in &self.statements {
···
 
 impl ast::Capture {
     fn evaluate_lazy(&self, exec: &mut ExecutionContext) -> Result<LazyValue, ExecutionError> {
-        Ok(query_capture_value(
-            self.file_capture_index,
-            self.quantifier,
-            exec.mat,
+        Ok(Value::from_nodes(
             exec.graph,
+            exec.mat
+                .nodes_for_capture_index(self.file_capture_index as u32),
+            self.quantifier,
         )
         .into())
     }

src/execution/strict.rs

···
 use crate::ast::Variable;
 use crate::execution::error::ExecutionError;
 use crate::execution::error::ResultWithExecutionError;
-use crate::execution::query_capture_value;
+use crate::execution::error::StatementContext;
 use crate::execution::CancellationFlag;
 use crate::execution::ExecutionConfig;
 use crate::graph::Attributes;
···
 use crate::variables::Variables;
 use crate::Identifier;
 use crate::Location;
-
-use super::error::StatementContext;
 
 impl File {
     /// Executes this graph DSL file against a source file, saving the results into an existing
···
 
 impl Capture {
     fn evaluate(&self, exec: &mut ExecutionContext) -> Result<Value, ExecutionError> {
-        Ok(query_capture_value(
-            self.stanza_capture_index,
+        Ok(Value::from_nodes(
+            exec.graph,
+            exec.mat
+                .nodes_for_capture_index(self.stanza_capture_index as u32),
             self.quantifier,
-            exec.mat,
-            exec.graph,
-        ))
+        )
+        .into())
     }
 }