Remove the old pass_result tree.

src/syntax.rs

@@ -1,4 +1,4 @@
-use codespan_reporting::files::SimpleFiles;
+use codespan_reporting::{files::SimpleFiles, diagnostic::Diagnostic};
 use lalrpop_util::lalrpop_mod;
 use logos::Logos;
 
@@ -74,6 +74,89 @@ impl ParserError {
     }
 }
 
+fn display_expected(expected: &[String]) -> String {
+    match expected.len() {
+        0 => "".to_string(),
+        1 => format!("; expected {}", expected[0]),
+        2 => format!("; expected {} or {}", expected[0], expected[1]),
+        n => format!(
+            "; expected {}or {}",
+            comma_separate(&expected[0..n - 1]),
+            expected[n - 1]
+        ),
+    }
+}
+
+fn comma_separate(strings: &[String]) -> String {
+    let mut result = String::new();
+
+    for s in strings.iter() {
+        result.push_str(s);
+        result.push_str(", ");
+    }
+
+    result
+}
+
+impl<'a> From<&'a ParserError> for Diagnostic<usize> {
+    fn from(value: &ParserError) -> Self {
+        match value {
+            // this was just a token we didn't understand
+            ParserError::InvalidToken(location) => location
+                .labelled_error("extremely odd token")
+                .with_message("encountered extremely confusing token"),
+
+            // unexpected EOF!
+            ParserError::UnrecognizedEOF(location, expected) => location.error().with_message(
+                format!("expected enf of file{}", display_expected(expected)),
+            ),
+
+            // encountered a token where it shouldn't be
+            ParserError::UnrecognizedToken(start, end, token, expected) => {
+                let expected_str =
+                    format!("unexpected token {}{}", token, display_expected(expected));
+                let unexpected_str = format!("unexpected token {}", token);
+                let mut labels = start.range_label(end);
+
+                Diagnostic::error()
+                    .with_labels(
+                        labels
+                            .drain(..)
+                            .map(|l| l.with_message(unexpected_str.clone()))
+                            .collect(),
+                    )
+                    .with_message(expected_str)
+            }
+
+            // I think we get this when we get a token, but were expected EOF
+            ParserError::ExtraToken(start, token, end) => {
+                let expected_str =
+                    format!("unexpected token {} after the expected end of file", token);
+                let unexpected_str = format!("unexpected token {}", token);
+                let mut labels = start.range_label(end);
+
+                Diagnostic::error()
+                    .with_labels(
+                        labels
+                            .drain(..)
+                            .map(|l| l.with_message(unexpected_str.clone()))
+                            .collect(),
+                    )
+                    .with_message(expected_str)
+            }
+
+            // simple lexer errors
+            ParserError::LexFailure(location) => {
+                location.error().with_message("unexpected character")
+            }
+
+            ParserError::FileDatabaseError(e) => Diagnostic::error().with_message(e.to_string()),
+
+            ParserError::ReadError(e) => Diagnostic::error().with_message(e.to_string()),
+        }
+    }
+}
+
 impl Program {
     pub fn parse_file(
         file_database: &mut SimpleFiles<String, String>,