1 files changed, 24 insertions, 31 deletions

diff --git a/src/lisp/parse.rs b/src/lisp/parse.rs
index 89a272a..4e0f427 100644
--- a/src/lisp/parse.rs
+++ b/src/lisp/parse.rs
@@ -1,5 +1,5 @@
 use crate::lisp::{
-    error::LispError,
+    error::{LispError, ParseError, ParseErrorKind},
     lex::{Lexer, Span, Token},
     number::LispNumber,
     LispExpr,
@@ -10,26 +10,6 @@ pub struct Parser<'lex> {
     cur_token: Option<(Span, Token<'lex>)>,
 }
 
-// pub struct ParseError {
-//     pub span: Span,
-//     pub kind: ParseErrorKind,
-// }
-//
-// pub enum ParseErrorKind {
-//     InvalidLiteral,
-//     InvalidToken,
-//     LiteralParseError,
-//     MissingCloseParen,
-//     UnbalancedComma,
-//     UnexpectedEof,
-//     UnexpectedToken {
-//         expected: &'static str,
-//         found: &'static str,
-//     },
-//     UnmatchedParen,
-//     UnterminatedString,
-// }
-
 enum Group {
     Backticks(i32),
     CommaAt,
@@ -49,7 +29,7 @@ impl<'lex> Parser<'lex> {
         let mut stack = Vec::new();
         let mut total_backticks = 0;
         loop {
-            let (_, token) = self.next()?;
+            let (span, token) = self.next()?;
             let r: Result<LispExpr, LispError> = match token {
                 Token::LeftParen => {
                     stack.push(Group::Parens(Vec::new()));
@@ -57,21 +37,27 @@ impl<'lex> Parser<'lex> {
                 }
                 Token::RightParen => {
                     let group = stack.pop().ok_or_else(
-                        || LispError::ParseError, // unmatched paren here
+                        || (ParseError::new(span, ParseErrorKind::UnmatchedParen)), // unmatched paren here
                     )?;
                     match group {
                         Group::Parens(v) => Ok(LispExpr::List(v)),
-                        _ => Err(LispError::ParseError),
+                        _ => Err(From::from(ParseError::new(
+                            span,
+                            ParseErrorKind::UnexpectedToken {
+                                expected: "expression",
+                                found: "(",
+                            },
+                        ))),
                     }
                 }
                 Token::Float(f) => f
                     .parse::<f64>()
                     .map(|n| LispExpr::Number(LispNumber::Float(n)))
-                    .map_err(|_| LispError::ParseError),
+                    .map_err(|_| ParseError::new(span, ParseErrorKind::LiteralParseError).into()),
                 Token::Integer(i) => i
                     .parse::<i64>()
                     .map(|n| LispExpr::Number(LispNumber::Integer(n)))
-                    .map_err(|_| LispError::ParseError),
+                    .map_err(|_| ParseError::new(span, ParseErrorKind::LiteralParseError).into()),
                 Token::String(s) => Ok(LispExpr::StringLit(s.into())),
                 Token::Name(n) => Ok(name_expr(n)),
                 Token::BackQuote => {
@@ -85,7 +71,7 @@ impl<'lex> Parser<'lex> {
                 }
                 Token::Comma => {
                     if total_backticks <= 0 {
-                        return Err(LispError::ParseError); // unbalanced comma
+                        return Err(ParseError::new(span, ParseErrorKind::UnbalancedComma).into());
                     }
                     total_backticks -= 1;
                     if let Some(&mut Group::Backticks(ref mut n)) = stack.last_mut() {
@@ -97,7 +83,7 @@ impl<'lex> Parser<'lex> {
                 }
                 Token::CommaAt => {
                     if total_backticks <= 0 {
-                        return Err(LispError::ParseError); // unbalanced comma
+                        return Err(ParseError::new(span, ParseErrorKind::UnbalancedComma).into());
                     }
                     total_backticks -= 1;
                     stack.push(Group::CommaAt);
@@ -118,9 +104,9 @@ impl<'lex> Parser<'lex> {
                     });
 
                     if any_paren {
-                        Err(LispError::ParseError) // unbalanced paren
+                        Err(ParseError::new(span, ParseErrorKind::MissingCloseParen).into())
                     } else {
-                        Err(LispError::ParseError) // unexpected eof
+                        Err(ParseError::new(span, ParseErrorKind::UnexpectedEof).into())
                     }
                 }
             };
@@ -178,7 +164,14 @@ impl<'lex> Parser<'lex> {
 
         match self.next()? {
             (_, Token::End) => Ok(expr),
-            _ => Err(LispError::ParseError), // too many tokens
+            (span, token) => Err(ParseError::new(
+                span,
+                ParseErrorKind::UnexpectedToken {
+                    expected: "EOF",
+                    found: token.name(),
+                },
+            )
+            .into()),
         }
     }