Prepare Excerpt for reuse for parse errors

src/execution/error.rs

···
 // Please see the LICENSE-APACHE or LICENSE-MIT files in this distribution for license details.
 // ------------------------------------------------------------------------------------------------
 
-#[cfg(feature = "term-colors")]
-use colored::Colorize;
 use std::path::Path;
 use thiserror::Error;
 
-use crate::ast::{Stanza, Statement};
+use crate::ast::Stanza;
+use crate::ast::Statement;
 use crate::execution::CancellationError;
+use crate::parse_error::Excerpt;
 use crate::Location;
 
 /// An error that can occur while executing a graph DSL file
···
                         write!(
                             f,
                             "{}",
-                            Excerpt::from_source(self.tsg_path, self.tsg, statement_location, 7)
+                            Excerpt::from_source(
+                                self.tsg_path,
+                                self.tsg,
+                                statement_location.row,
+                                statement_location.to_column_range(),
+                                7
+                            )
                         )?;
                         writeln!(f, "{}in stanza", " ".repeat(7))?;
                         write!(
                             f,
                             "{}",
-                            Excerpt::from_source(self.tsg_path, self.tsg, stanza_location, 7)
+                            Excerpt::from_source(
+                                self.tsg_path,
+                                self.tsg,
+                                stanza_location.row,
+                                stanza_location.to_column_range(),
+                                7
+                            )
                         )?;
                         writeln!(f, "{}matching ({}) node", " ".repeat(7), node_kind)?;
                         write!(
                             f,
                             "{}",
-                            Excerpt::from_source(self.source_path, self.source, source_location, 7)
+                            Excerpt::from_source(
+                                self.source_path,
+                                self.source,
+                                source_location.row,
+                                source_location.to_column_range(),
+                                7
+                            )
                         )?;
                         Ok(())
                     }
···
         }
     }
 }
-
-/// Excerpts of source from either the target language file or the tsg rules file.
-struct Excerpt<'a> {
-    path: &'a Path,
-    source: Option<&'a str>,
-    location: &'a Location,
-    indent: usize,
-}
-
-impl<'a> Excerpt<'a> {
-    pub fn from_source(
-        path: &'a Path,
-        source: &'a str,
-        location: &'a Location,
-        indent: usize,
-    ) -> Excerpt<'a> {
-        Excerpt {
-            path,
-            source: source.lines().nth(location.row),
-            location,
-            indent,
-        }
-    }
-
-    fn gutter_width(&self) -> usize {
-        ((self.location.row + 1) as f64).log10() as usize + 1
-    }
-}
-
-impl<'a> std::fmt::Display for Excerpt<'a> {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        // path and line/col
-        write!(
-            f,
-            "{}{}:{}:{}:",
-            " ".repeat(self.indent),
-            white_bold(&self.path.to_str().unwrap_or("<unknown file>")),
-            white_bold(&format!("{}", self.location.row + 1)),
-            white_bold(&format!("{}", self.location.column + 1)),
-        )?;
-        if let Some(source) = self.source {
-            writeln!(f)?;
-            // first line: line number & source
-            writeln!(
-                f,
-                "{}{}{}{}",
-                " ".repeat(self.indent),
-                blue(&format!("{}", self.location.row + 1)),
-                blue(" | "),
-                source,
-            )?;
-            // second line: caret
-            writeln!(
-                f,
-                "{}{}{}{}{}",
-                " ".repeat(self.indent),
-                " ".repeat(self.gutter_width()),
-                blue(" | "),
-                " ".repeat(self.location.column),
-                green_bold("^")
-            )?;
-        } else {
-            writeln!(f, " <missing source>")?;
-        }
-        Ok(())
-    }
-}
-
-// coloring functions
-
-#[cfg(feature = "term-colors")]
-fn blue(str: &str) -> impl std::fmt::Display {
-    str.blue()
-}
-#[cfg(not(feature = "term-colors"))]
-fn blue<'a>(str: &'a str) -> impl std::fmt::Display + 'a {
-    str
-}
-
-#[cfg(feature = "term-colors")]
-fn green_bold(str: &str) -> impl std::fmt::Display {
-    str.green().bold()
-}
-#[cfg(not(feature = "term-colors"))]
-fn green_bold<'a>(str: &'a str) -> impl std::fmt::Display + 'a {
-    str
-}
-
-#[cfg(feature = "term-colors")]
-fn white_bold(str: &str) -> impl std::fmt::Display {
-    str.white().bold()
-}
-#[cfg(not(feature = "term-colors"))]
-fn white_bold<'a>(str: &'a str) -> impl std::fmt::Display + 'a {
-    str
-}

src/parse_error.rs

···
 
 //! Data types and functions for finding and displaying tree-sitter parse errors.
 
+#[cfg(feature = "term-colors")]
+use colored::Colorize;
+use std::ops::Range;
+use std::path::Path;
 use tree_sitter::Node;
 use tree_sitter::Tree;
 
···
         }
     }
 
-    pub fn display(&self, source: &'tree str, verbose: bool) -> ParseErrorDisplay {
+    pub fn display<'a: 'tree>(
+        &'a self,
+        source: &'tree str,
+        verbose: bool,
+    ) -> impl std::fmt::Display + 'a + 'tree {
         ParseErrorDisplay {
             error: self,
             source,
···
     }
 }
 
-pub struct ParseErrorDisplay<'tree> {
+struct ParseErrorDisplay<'tree> {
     error: &'tree ParseError<'tree>,
     source: &'tree str,
     verbose: bool,
···
 // This is okay because Send and Sync _are_ implemented for Tree, which also holds ffi::TSTree
 unsafe impl Send for TreeWithParseErrorVec {}
 unsafe impl Sync for TreeWithParseErrorVec {}
+
+//-----------------------------------------------------------------------------
+
+/// Excerpts of source from either the target language file or the tsg rules file.
+pub(crate) struct Excerpt<'a> {
+    path: &'a Path,
+    source: Option<&'a str>,
+    row: usize,
+    columns: Range<usize>,
+    indent: usize,
+}
+
+impl<'a> Excerpt<'a> {
+    pub fn from_source(
+        path: &'a Path,
+        source: &'a str,
+        row: usize,
+        columns: Range<usize>,
+        indent: usize,
+    ) -> Excerpt<'a> {
+        Excerpt {
+            path,
+            source: source.lines().nth(row),
+            row,
+            columns,
+            indent,
+        }
+    }
+
+    fn gutter_width(&self) -> usize {
+        ((self.row + 1) as f64).log10() as usize + 1
+    }
+}
+
+impl<'a> std::fmt::Display for Excerpt<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        // path and line/col
+        writeln!(
+            f,
+            "{}{}:{}:{}:",
+            " ".repeat(self.indent),
+            white_bold(&self.path.to_str().unwrap_or("<unknown file>")),
+            white_bold(&format!("{}", self.row + 1)),
+            white_bold(&format!("{}", self.columns.start + 1)),
+        )?;
+        if let Some(source) = self.source {
+            // first line: line number & source
+            writeln!(
+                f,
+                "{}{}{}{}",
+                " ".repeat(self.indent),
+                blue(&format!("{}", self.row + 1)),
+                blue(" | "),
+                source,
+            )?;
+            // second line: caret
+            writeln!(
+                f,
+                "{}{}{}{}{}",
+                " ".repeat(self.indent),
+                " ".repeat(self.gutter_width()),
+                blue(" | "),
+                " ".repeat(self.columns.start),
+                green_bold(&"^".repeat(self.columns.len()))
+            )?;
+        } else {
+            writeln!(f, "{}{}", " ".repeat(self.indent), "<missing source>",)?;
+        }
+        Ok(())
+    }
+}
+
+// coloring functions
+
+#[cfg(feature = "term-colors")]
+fn blue(str: &str) -> impl std::fmt::Display {
+    str.blue()
+}
+#[cfg(not(feature = "term-colors"))]
+fn blue<'a>(str: &'a str) -> impl std::fmt::Display + 'a {
+    str
+}
+
+#[cfg(feature = "term-colors")]
+fn green_bold(str: &str) -> impl std::fmt::Display {
+    str.green().bold()
+}
+#[cfg(not(feature = "term-colors"))]
+fn green_bold<'a>(str: &'a str) -> impl std::fmt::Display + 'a {
+    str
+}
+
+#[cfg(feature = "term-colors")]
+fn white_bold(str: &str) -> impl std::fmt::Display {
+    str.white().bold()
+}
+#[cfg(not(feature = "term-colors"))]
+fn white_bold<'a>(str: &'a str) -> impl std::fmt::Display + 'a {
+    str
+}

src/parser.rs

···
 
 use std::fmt::Display;
 use std::iter::Peekable;
+use std::ops::Range;
 use std::str::Chars;
 
 use regex::Regex;
···
         } else {
             self.column += 1;
         }
+    }
+
+    pub(crate) fn to_column_range(&self) -> Range<usize> {
+        self.column..self.column + 1
     }
 }