Merge pull request #125 from tree-sitter/pretty-parse-errors

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
+
+### Library
+
+#### Changed
+
+- The method `ParseError::display(source: &str, verbose: bool)` has been replaced by two methods `ParseError::display(path: &path, source: &str)` and `ParseError::display_pretty(path: &Path, source: &str)`.
+
+### CLI
+
+#### Changed
+
+- Parse errors are now displayed with the same excerpt style as execution errors.
+
 ## 0.8.0 -- 2023-03-29
 
 ### Library

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

···
         let parse_errors = ParseError::all(&tree);
         if !parse_errors.is_empty() {
             for parse_error in parse_errors.iter().take(MAX_PARSE_ERRORS) {
-                let line = parse_error.node().start_position().row;
-                let column = parse_error.node().start_position().column;
-                eprintln!(
-                    "{}:{}:{}: {}",
-                    source_path.display(),
-                    line + 1,
-                    column + 1,
-                    parse_error.display(&source, true)
-                );
+                eprintln!("{}", parse_error.display_pretty(source_path, &source));
             }
             if parse_errors.len() > MAX_PARSE_ERRORS {
                 let more_errors = parse_errors.len() - MAX_PARSE_ERRORS;
···
     let graph = match file.execute(&tree, &source, &mut config, &NoCancellation) {
         Ok(graph) => graph,
         Err(e) => {
-            eprint!("{}", e.display_pretty(source_path, &source, tsg_path, &tsg));
+            eprintln!("{}", e.display_pretty(source_path, &source, tsg_path, &tsg));
             return Err(anyhow!("Cannot execute TSG file {}", tsg_path.display()));
         }
     };

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(
+        &'tree self,
+        path: &'tree Path,
+        source: &'tree str,
+    ) -> impl std::fmt::Display + 'tree {
         ParseErrorDisplay {
             error: self,
+            path,
             source,
-            verbose,
+        }
+    }
+
+    pub fn display_pretty(
+        &'tree self,
+        path: &'tree Path,
+        source: &'tree str,
+    ) -> impl std::fmt::Display + 'tree {
+        ParseErrorDisplayPretty {
+            error: self,
+            path,
+            source,
         }
     }
 }
 
-pub struct ParseErrorDisplay<'tree> {
+struct ParseErrorDisplay<'tree> {
     error: &'tree ParseError<'tree>,
+    path: &'tree Path,
     source: &'tree str,
-    verbose: bool,
 }
 
 impl std::fmt::Display for ParseErrorDisplay<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let node = self.error.node();
+        write!(
+            f,
+            "{}:{}:{}: ",
+            self.path.display(),
+            node.start_position().row + 1,
+            node.start_position().column + 1
+        )?;
         let node = match self.error {
             ParseError::Missing(node) => {
-                write!(f, "Missing syntax")?;
+                write!(f, "missing syntax")?;
                 node
             }
             ParseError::Unexpected(node) => {
-                write!(f, "Unexpected syntax")?;
+                write!(f, "unexpected syntax")?;
                 node
             }
         };
-        let line = node.start_position().row;
-        let start_column = node.start_position().column;
         if node.byte_range().is_empty() {
             writeln!(f, "")?;
         } else {
-            let (end_column, end_byte) = self.source[node.byte_range()]
+            let end_byte = self.source[node.byte_range()]
                 .chars()
                 .take_while(|c| *c != '\n')
-                .fold(
-                    (node.start_position().column, node.start_byte()),
-                    |(column, byte), c| (column + 1, byte + c.len_utf8()),
-                );
-            if !self.verbose {
-                let text = &self.source[node.start_byte()..end_byte];
-                write!(f, ": {}", text)?;
-            } else {
-                let text = self
-                    .source
-                    .lines()
-                    .nth(line)
-                    .expect("parse error has invalid row");
-                writeln!(f, ":")?;
-                writeln!(f, "")?;
-                writeln!(f, "| {}", text)?;
-                write!(
-                    f,
-                    "  {}{}",
-                    " ".repeat(start_column),
-                    "^".repeat(end_column - start_column)
-                )?;
-                if node.end_position().row == line {
-                    writeln!(f, "")?;
-                } else {
-                    writeln!(f, "...")?;
-                }
+                .map(|c| c.len_utf8())
+                .sum();
+            let text = &self.source[node.start_byte()..end_byte];
+            write!(f, ": {}", text)?;
+        }
+        Ok(())
+    }
+}
+
+struct ParseErrorDisplayPretty<'tree> {
+    error: &'tree ParseError<'tree>,
+    path: &'tree Path,
+    source: &'tree str,
+}
+
+impl std::fmt::Display for ParseErrorDisplayPretty<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let node = match self.error {
+            ParseError::Missing(node) => {
+                writeln!(f, "missing syntax")?;
+                node
             }
+            ParseError::Unexpected(node) => {
+                writeln!(f, "unexpected syntax")?;
+                node
+            }
+        };
+        if node.byte_range().is_empty() {
+            writeln!(f, "")?;
+        } else {
+            let start_column = node.start_position().column;
+            let end_column = node.start_position().column
+                + self.source[node.byte_range()]
+                    .chars()
+                    .take_while(|c| *c != '\n')
+                    .count();
+            write!(
+                f,
+                "{}",
+                Excerpt::from_source(
+                    self.path,
+                    self.source,
+                    node.start_position().row,
+                    start_column..end_column,
+                    0,
+                ),
+            )?;
         }
         Ok(())
     }
···
 // 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
     }
 }