From c84c38544bc6e81f0b0482e4e82b6c95848c1a0c Mon Sep 17 00:00:00 2001 From: Akshay Date: Tue, 6 Apr 2021 14:54:54 +0530 Subject: apply clippy lints --- src/lisp/parse.rs | 159 ++++++++++++++++++++++++++---------------------------- 1 file changed, 76 insertions(+), 83 deletions(-) (limited to 'src/lisp/parse.rs') diff --git a/src/lisp/parse.rs b/src/lisp/parse.rs index 737e7ad..8aeb672 100644 --- a/src/lisp/parse.rs +++ b/src/lisp/parse.rs @@ -1,5 +1,5 @@ use crate::lisp::{ - error::{LispError, ParseError, ParseErrorKind}, + error::{ParseError, ParseErrorKind}, lex::{Lexer, Span, Token}, number::LispNumber, LispExpr, @@ -30,97 +30,91 @@ impl<'lex> Parser<'lex> { let mut total_backticks = 0; loop { let (span, token) = self.next()?; - let r: Result = match token { - Token::LeftParen => { - stack.push(Group::Parens(Vec::new())); - continue; - } - Token::RightParen => { - let group = stack - .pop() - .ok_or_else(|| (ParseError::new(span, ParseErrorKind::UnmatchedParen)))?; - match group { - Group::Parens(v) => { - if v.len() == 0 { - Ok(LispExpr::Unit) - } else { - Ok(LispExpr::List(v)) + let r: Result = + match token { + Token::LeftParen => { + stack.push(Group::Parens(Vec::new())); + continue; + } + Token::RightParen => { + let group = stack + .pop() + .ok_or_else(|| ParseError::new(span, ParseErrorKind::UnmatchedParen))?; + match group { + Group::Parens(v) => { + if v.is_empty() { + Ok(LispExpr::Unit) + } else { + Ok(LispExpr::List(v)) + } } + _ => Err(ParseError::new( + span, + ParseErrorKind::UnexpectedToken { + expected: "expression", + found: "(", + }, + )), } - _ => Err(From::from(ParseError::new( - span, - ParseErrorKind::UnexpectedToken { - expected: "expression", - found: "(", - }, - ))), } - } - Token::Float(f) => f - .parse::() - .map(|n| LispExpr::Number(LispNumber::Float(n))) - .map_err(|_| ParseError::new(span, ParseErrorKind::LiteralParseError).into()), - Token::Integer(i) => i - .parse::() - .map(|n| LispExpr::Number(LispNumber::Integer(n))) - .map_err(|_| ParseError::new(span, ParseErrorKind::LiteralParseError).into()), - Token::String(s) => Ok(LispExpr::StringLit(s[1..s.len() - 1].into())), - Token::Char(s) => { - Ok(LispExpr::Char(s.chars().nth(2).ok_or_else(|| { + Token::Float(f) => f + .parse::() + .map(|n| LispExpr::Number(LispNumber::Float(n))) + .map_err(|_| ParseError::new(span, ParseErrorKind::LiteralParseError)), + Token::Integer(i) => i + .parse::() + .map(|n| LispExpr::Number(LispNumber::Integer(n))) + .map_err(|_| ParseError::new(span, ParseErrorKind::LiteralParseError)), + Token::String(s) => Ok(LispExpr::StringLit(s[1..s.len() - 1].into())), + Token::Char(s) => Ok(LispExpr::Char(s.chars().nth(2).ok_or_else(|| { ParseError::new(span, ParseErrorKind::LiteralParseError) - })?)) - } - Token::Name(n) => Ok(name_expr(n)), - Token::BackQuote => { - total_backticks += 1; - if let Some(&mut Group::Backticks(ref mut n)) = stack.last_mut() { - *n += 1; + })?)), + Token::Name(n) => Ok(name_expr(n)), + Token::BackQuote => { + total_backticks += 1; + if let Some(&mut Group::Backticks(ref mut n)) = stack.last_mut() { + *n += 1; + continue; + } + stack.push(Group::Backticks(1)); continue; } - stack.push(Group::Backticks(1)); - continue; - } - Token::Comma => { - if total_backticks <= 0 { - return Err(ParseError::new(span, ParseErrorKind::UnbalancedComma)); - } - total_backticks -= 1; - if let Some(&mut Group::Backticks(ref mut n)) = stack.last_mut() { - *n -= 1; + Token::Comma => { + if total_backticks <= 0 { + return Err(ParseError::new(span, ParseErrorKind::UnbalancedComma)); + } + total_backticks -= 1; + if let Some(&mut Group::Backticks(ref mut n)) = stack.last_mut() { + *n -= 1; + continue; + } + stack.push(Group::Backticks(-1)); continue; } - stack.push(Group::Backticks(-1)); - continue; - } - Token::CommaAt => { - if total_backticks <= 0 { - return Err(ParseError::new(span, ParseErrorKind::UnbalancedComma)); + Token::CommaAt => { + if total_backticks <= 0 { + return Err(ParseError::new(span, ParseErrorKind::UnbalancedComma)); + } + total_backticks -= 1; + stack.push(Group::CommaAt); + continue; } - total_backticks -= 1; - stack.push(Group::CommaAt); - continue; - } - Token::Quote => { - if let Some(&mut Group::Quotes(ref mut n)) = stack.last_mut() { - *n += 1; + Token::Quote => { + if let Some(&mut Group::Quotes(ref mut n)) = stack.last_mut() { + *n += 1; + continue; + } + stack.push(Group::Quotes(1)); continue; } - stack.push(Group::Quotes(1)); - continue; - } - Token::End => { - let any_paren = stack.iter().any(|group| match *group { - Group::Parens(_) => true, - _ => false, - }); - - if any_paren { - Err(ParseError::new(span, ParseErrorKind::MissingCloseParen)) - } else { - Err(ParseError::new(span, ParseErrorKind::UnexpectedEof)) + Token::End => { + if stack.iter().any(|group| matches!(*group, Group::Parens(_))) { + Err(ParseError::new(span, ParseErrorKind::MissingCloseParen)) + } else { + Err(ParseError::new(span, ParseErrorKind::UnexpectedEof)) + } } - } - }; + }; let mut v = r?; loop { match stack.last_mut() { @@ -181,8 +175,7 @@ impl<'lex> Parser<'lex> { expected: "EOF", found: token.name(), }, - ) - .into()), + )), } } @@ -210,7 +203,7 @@ fn name_expr(input: &str) -> LispExpr { mod tests { use super::*; fn parse(input: &str) -> Result { - let mut parser = Parser::new(Lexer::new(input, 0)); + let mut parser = Parser::new(Lexer::new(input)); parser.parse_single_expr() } -- cgit v1.2.3