Pretty errors for TSG parsing and checking

CHANGELOG.md

···
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## Unreleased
+
+### CLI
+
+#### Added
+
+- Errors from parsing and checking the TSG file are now displayed with source excerpts.
+
 ## v0.9.0 -- 2023-03-31
 
 ### Library

src/bin/tree-sitter-graph/main.rs

···
     let tsg = std::fs::read(tsg_path)
         .with_context(|| format!("Cannot read TSG file {}", tsg_path.display()))?;
     let tsg = String::from_utf8(tsg)?;
-    let file = File::from_str(language, &tsg)
-        .with_context(|| format!("Cannot parsing TSG file {}", tsg_path.display()))?;
+    let file = match File::from_str(language, &tsg) {
+        Ok(file) => file,
+        Err(err) => {
+            eprintln!("{}", err.display_pretty(tsg_path, &tsg));
+            return Err(anyhow!("Cannot parse TSG file {}", tsg_path.display()));
+        }
+    };
 
     let source = std::fs::read(source_path)
         .with_context(|| format!("Cannot read source file {}", source_path.display()))?;

src/checker.rs

···
 // Please see the LICENSE-APACHE or LICENSE-MIT files in this distribution for license details.
 // ------------------------------------------------------------------------------------------------
 
+use std::path::Path;
+
 use thiserror::Error;
 use tree_sitter::CaptureQuantifier;
 use tree_sitter::CaptureQuantifier::One;
···
 use tree_sitter::Query;
 
 use crate::ast;
+use crate::parse_error::Excerpt;
 use crate::parser::FULL_MATCH;
 use crate::variables::MutVariables;
 use crate::variables::VariableError;
···
     UndefinedSyntaxCapture(String, Location),
     #[error("Undefined variable {0} at {1}")]
     UndefinedVariable(String, Location),
-    #[error("{0}: {1}")]
-    Variable(VariableError, String),
+    #[error("{0}: {1} at {2}")]
+    Variable(VariableError, String, Location),
+}
+
+impl CheckError {
+    pub fn display_pretty<'a>(
+        &'a self,
+        path: &'a Path,
+        source: &'a str,
+    ) -> impl std::fmt::Display + 'a {
+        DisplayCheckErrorPretty {
+            error: self,
+            path,
+            source,
+        }
+    }
+}
+
+struct DisplayCheckErrorPretty<'a> {
+    error: &'a CheckError,
+    path: &'a Path,
+    source: &'a str,
+}
+
+impl std::fmt::Display for DisplayCheckErrorPretty<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let location = match self.error {
+            CheckError::CannotHideGlobalVariable(_, location) => *location,
+            CheckError::CannotSetGlobalVariable(_, location) => *location,
+            CheckError::DuplicateGlobalVariable(_, location) => *location,
+            CheckError::ExpectedListValue(location) => *location,
+            CheckError::ExpectedLocalValue(location) => *location,
+            CheckError::ExpectedOptionalValue(location) => *location,
+            CheckError::NullableRegex(_, location) => *location,
+            CheckError::UndefinedSyntaxCapture(_, location) => *location,
+            CheckError::UndefinedVariable(_, location) => *location,
+            CheckError::Variable(_, _, location) => *location,
+        };
+        writeln!(f, "{}", self.error)?;
+        write!(
+            f,
+            "{}",
+            Excerpt::from_source(
+                self.path,
+                self.source,
+                location.row,
+                location.to_column_range(),
+                0
+            )
+        )?;
+        Ok(())
+    }
 }
 
 /// Checker context
···
         }
         ctx.locals
             .add(self.name.clone(), value, mutable)
-            .map_err(|e| CheckError::Variable(e, format!("{}", self.name)))
+            .map_err(|e| CheckError::Variable(e, format!("{}", self.name), self.location))
     }
 
     fn check_set(
···
         value.is_local = false;
         ctx.locals
             .set(self.name.clone(), value)
-            .map_err(|e| CheckError::Variable(e, format!("{}", self.name)))
+            .map_err(|e| CheckError::Variable(e, format!("{}", self.name), self.location))
     }
 
     fn check_get(&mut self, ctx: &mut CheckContext) -> Result<ExpressionResult, CheckError> {

src/parser.rs

···
 use std::fmt::Display;
 use std::iter::Peekable;
 use std::ops::Range;
+use std::path::Path;
 use std::str::Chars;
 
 use regex::Regex;
···
 use tree_sitter::QueryError;
 
 use crate::ast;
+use crate::parse_error::Excerpt;
 use crate::Identifier;
 
 pub const FULL_MATCH: &str = "__tsg__full_match";
···
         Parser::new(content).parse_into_file(self)
     }
 }
+
+// ----------------------------------------------------------------------------
+// Parse errors
 
 /// An error that can occur while parsing a graph DSL file
 #[derive(Debug, Error)]
···
     Check(#[from] crate::checker::CheckError),
 }
 
+impl ParseError {
+    pub fn display_pretty<'a>(
+        &'a self,
+        path: &'a Path,
+        source: &'a str,
+    ) -> impl std::fmt::Display + 'a {
+        DisplayParseErrorPretty {
+            error: self,
+            path,
+            source,
+        }
+    }
+}
+
+struct DisplayParseErrorPretty<'a> {
+    error: &'a ParseError,
+    path: &'a Path,
+    source: &'a str,
+}
+
+impl std::fmt::Display for DisplayParseErrorPretty<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let location = match self.error {
+            ParseError::ExpectedQuantifier(location) => *location,
+            ParseError::ExpectedToken(_, location) => *location,
+            ParseError::ExpectedVariable(location) => *location,
+            ParseError::ExpectedUnscopedVariable(location) => *location,
+            ParseError::InvalidRegex(_, location) => *location,
+            ParseError::InvalidRegexCapture(location) => *location,
+            ParseError::QueryError(err) => Location {
+                row: err.row,
+                column: err.column,
+            },
+            ParseError::UnexpectedCharacter(_, _, location) => *location,
+            ParseError::UnexpectedEOF(location) => *location,
+            ParseError::UnexpectedKeyword(_, location) => *location,
+            ParseError::UnexpectedLiteral(_, location) => *location,
+            ParseError::UnexpectedQueryPatterns(location) => *location,
+            ParseError::Check(err) => {
+                write!(f, "{}", err.display_pretty(self.path, self.source))?;
+                return Ok(());
+            }
+        };
+        writeln!(f, "{}", self.source)?;
+        writeln!(f, "{}", self.error)?;
+        write!(
+            f,
+            "{}",
+            Excerpt::from_source(
+                self.path,
+                self.source,
+                location.row,
+                location.to_column_range(),
+                0
+            )
+        )?;
+        Ok(())
+    }
+}
+
+// ----------------------------------------------------------------------------
+// Location
+
 /// The location of a graph DSL entity within its file
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
 pub struct Location {
···
         write!(f, "({}, {})", self.row + 1, self.column + 1)
     }
 }
+
+// ----------------------------------------------------------------------------
+// Parser
 
 struct Parser<'a> {
     source: &'a str,