fix trailing comma and close bracket handling

src/ast.rs

@@ -110,6 +110,15 @@ enum ArraySyntax {
     Long,
 }
 
+impl ArraySyntax {
+    fn close_bracket(&self) -> Token {
+        match self {
+            ArraySyntax::Long => Token::BracketClose,
+            ArraySyntax::Short => Token::SquareClose,
+        }
+    }
+}
+
 fn parse_array<'source>(
     source: &'source str,
     lexer: &mut Lexer<Token>,
@@ -129,32 +138,27 @@ fn parse_array<'source>(
             Ok(value) => value,
             Err(err) => {
                 // trailing comma or empty array
-                if matches!(
+                match err.error() {
-                    err.error(),
+                    ParseError::UnexpectedToken(UnexpectedTokenError {
-                    ParseError::UnexpectedToken(UnexpectedTokenError { found: None, .. })
+                        found: Some(token),
-                ) {
+                        ..
-                    break;
+                    }) if token == &syntax.close_bracket() => break,
-                } else {
+                    _ => return Err(err),
-                    return Err(err);
                 }
             }
         };
         let key_or_value_span = lexer.span();
         let next = lexer
             .next()
-            .expect_token(if syntax == ArraySyntax::Long {
+            .expect_token(&[syntax.close_bracket(), Token::Comma, Token::Arrow])
-                &[Token::BracketClose, Token::Comma, Token::Arrow]
-            } else {
-                &[Token::SquareClose, Token::Comma, Token::Arrow]
-            })
             .with_span(lexer.span(), source)?;
 
         match next {
-            Token::BracketClose if syntax == ArraySyntax::Long => {
+            Token::BracketClose => {
                 builder.push_value(key_or_value);
                 break;
             }
-            Token::SquareClose if syntax == ArraySyntax::Short => {
+            Token::SquareClose => {
                 builder.push_value(key_or_value);
                 break;
             }
@@ -177,11 +181,7 @@ fn parse_array<'source>(
 
                 match lexer
                     .next()
-                    .expect_token(if syntax == ArraySyntax::Long {
+                    .expect_token(&[syntax.close_bracket(), Token::Comma])
-                        &[Token::BracketClose, Token::Comma]
-                    } else {
-                        &[Token::SquareClose, Token::Comma]
-                    })
                     .with_span(lexer.span(), source)?
                 {
                     Token::BracketClose => {

src/error.rs

@@ -98,13 +98,16 @@ impl From<UnescapeError> for ParseError {
 #[derive(Error, Debug)]
 #[error("Unexpected token, found {found:?} expected one of {expected:?}")]
 pub struct UnexpectedTokenError {
-    pub expected: &'static [Token],
+    pub expected: Vec<Token>,
     pub found: Option<Token>,
 }
 
 impl UnexpectedTokenError {
-    pub fn new(expected: &'static [Token], found: Option<Token>) -> Self {
+    pub fn new(expected: &[Token], found: Option<Token>) -> Self {
-        UnexpectedTokenError { expected, found }
+        UnexpectedTokenError {
+            expected: expected.to_vec(),
+            found,
+        }
     }
 }
 
@@ -113,13 +116,13 @@ impl UnexpectedTokenError {
 pub struct InvalidArrayKeyError(pub Value);
 
 pub trait ExpectToken {
-    fn expect_token(self, expected: &'static [Token]) -> Result<Token, UnexpectedTokenError>;
+    fn expect_token(self, expected: &[Token]) -> Result<Token, UnexpectedTokenError>;
 }
 
 impl ExpectToken for Option<Token> {
-    fn expect_token(self, expected: &'static [Token]) -> Result<Token, UnexpectedTokenError> {
+    fn expect_token(self, expected: &[Token]) -> Result<Token, UnexpectedTokenError> {
         self.ok_or_else(|| UnexpectedTokenError {
-            expected,
+            expected: expected.to_vec(),
             found: None,
         })
         .and_then(|token| token.expect_token(expected))
@@ -127,13 +130,13 @@ impl ExpectToken for Option<Token> {
 }
 
 impl ExpectToken for Token {
-    fn expect_token(self, expected: &'static [Token]) -> Result<Token, UnexpectedTokenError> {
+    fn expect_token(self, expected: &[Token]) -> Result<Token, UnexpectedTokenError> {
         if expected.iter().any(|expect| self.eq(expect)) {
             Ok(self)
         } else {
             Err(UnexpectedTokenError {
-                expected,
+                expected: expected.to_vec(),
-                found: None,
+                found: Some(self),
             })
         }
     }