Track range of stanza, not just start lcocation

src/ast.rs

···
 use tree_sitter::Language;
 use tree_sitter::Query;
 
+use crate::parser::Range;
 use crate::Identifier;
 use crate::Location;
 
···
     pub full_match_stanza_capture_index: usize,
     /// Capture index of the full match in the file query
     pub full_match_file_capture_index: usize,
-    pub location: Location,
+    pub range: Range,
 }
 
 /// A statement that can appear in a graph DSL stanza

src/checker.rs

···
         if !unused_captures.is_empty() {
             return Err(CheckError::UnusedCaptures(
                 unused_captures.join(" "),
-                self.location,
+                self.range.start,
             ));
         }
 

src/execution.rs

···
                     mat,
                     full_capture_index: stanza.full_match_file_capture_index as u32,
                     named_captures,
-                    query_location: stanza.location,
+                    query_location: stanza.range.start,
                 })
             })
         } else {
···
                     mat,
                     full_capture_index: stanza.full_match_stanza_capture_index as u32,
                     named_captures,
-                    query_location: stanza.location,
+                    query_location: stanza.range.start,
                 })
             })
         }
···
                 mat,
                 full_capture_index: self.full_match_stanza_capture_index as u32,
                 named_captures,
-                query_location: self.location,
+                query_location: self.range.start,
             })
         })
     }

src/execution/error.rs

···
         Self {
             statement: format!("{}", stmt),
             statement_location: stmt.location(),
-            stanza_location: stanza.location,
+            stanza_location: stanza.range.start,
             source_location: Location::from(source_node.range().start_point),
             node_kind: source_node.kind().to_string(),
         }

src/execution/lazy.rs

···
             .nodes_for_capture_index(self.full_match_file_capture_index as u32)
             .next()
             .expect("missing capture for full match");
-        debug!("match {:?} at {}", node, self.location);
+        debug!("match {:?} at {}", node, self.range.start);
         trace!("{{");
         for statement in &self.statements {
             let error_context = { StatementContext::new(&statement, &self, &node) };

src/parser.rs

···
 
 use std::fmt::Display;
 use std::iter::Peekable;
-use std::ops::Range;
 use std::path::Path;
 use std::str::Chars;
 
···
         }
     }
 
-    pub(crate) fn to_column_range(&self) -> Range<usize> {
+    pub(crate) fn to_column_range(&self) -> std::ops::Range<usize> {
         self.column..self.column + 1
     }
 }
···
 }
 
 // ----------------------------------------------------------------------------
+// Range
+
+/// The range of a graph DSL entity within its file
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub struct Range {
+    pub start: Location,
+    pub end: Location,
+}
+
+impl Display for Range {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{} - {}", self.start, self.end)
+    }
+}
+
+// ----------------------------------------------------------------------------
 // Parser
 
 struct Parser<'a> {
···
     }
 
     fn parse_stanza(&mut self, language: Language) -> Result<ast::Stanza, ParseError> {
-        let location = self.location;
+        let start = self.location;
         let (query, full_match_stanza_capture_index) = self.parse_query(language)?;
         self.consume_whitespace();
         let statements = self.parse_statements()?;
+        let end = self.location;
+        let range = Range { start, end };
         Ok(ast::Stanza {
             query,
             statements,
             full_match_stanza_capture_index,
             full_match_file_capture_index: usize::MAX, // set in checker
-            location,
+            range,
         })
     }